Remove Peepmatic!!!

Peepmatic was an early attempt at a DSL for peephole optimizations, with the
idea that maybe sometime in the future we could user it for instruction
selection as well. It didn't really pan out, however:

* Peepmatic wasn't quite flexible enough, and adding new operators or snippets
  of code implemented externally in Rust was a bit of a pain.

* The performance was never competitive with the hand-written peephole
  optimizers. It was *very* size efficient, but that came at the cost of
  run-time efficiency. Everything was table-based and interpreted, rather than
  generating any Rust code.

Ultimately, because of these reasons, we never turned Peepmatic on by default.

These days, we just landed the ISLE domain-specific language, and it is better
suited than Peepmatic for all the things that Peepmatic was originally designed
to do. It is more flexible and easy to integrate with external Rust code. It is
has better time efficiency, meeting or even beating hand-written code. I think a
small part of the reason why ISLE excels in these things is because its design
was informed by Peepmatic's failures. I still plan on continuing Peepmatic's
mission to make Cranelift's peephole optimizer passes generated from DSL rewrite
rules, but using ISLE instead of Peepmatic.

Thank you Peepmatic, rest in peace!

cranelift/codegen/src/simple_preopt.rs

@@ -608,48 +608,6 @@ fn branch_order(pos: &mut FuncCursor, cfg: &mut ControlFlowGraph, block: Block,
     cfg.recompute_block(pos.func, block);
 }
 
-#[cfg(feature = "enable-peepmatic")]
-mod simplify {
-    use super::*;
-    use crate::peepmatic::ValueOrInst;
-
-    pub type PeepholeOptimizer<'a, 'b> =
-        peepmatic_runtime::optimizer::PeepholeOptimizer<'static, 'a, &'b dyn TargetIsa>;
-
-    pub fn peephole_optimizer<'a, 'b>(isa: &'b dyn TargetIsa) -> PeepholeOptimizer<'a, 'b> {
-        crate::peepmatic::preopt(isa)
-    }
-
-    pub fn apply_all<'a, 'b>(
-        optimizer: &mut PeepholeOptimizer<'a, 'b>,
-        pos: &mut FuncCursor<'a>,
-        inst: Inst,
-        _native_word_width: u32,
-    ) {
-        // After we apply one optimization, that might make another
-        // optimization applicable. Keep running the peephole optimizer
-        // until either:
-        //
-        // * No optimization applied, and therefore it doesn't make sense to
-        //   try again, because no optimization will apply again.
-        //
-        // * Or when we replaced an instruction with an alias to an existing
-        //   value, because we already ran the peephole optimizer over the
-        //   aliased value's instruction in an early part of the traversal
-        //   over the function.
-        while let Some(ValueOrInst::Inst(new_inst)) =
-            optimizer.apply_one(pos, ValueOrInst::Inst(inst))
-        {
-            // We transplanted a new instruction into the current
-            // instruction, so the "new" instruction is actually the same
-            // one, just with different data.
-            debug_assert_eq!(new_inst, inst);
-        }
-        debug_assert_eq!(pos.current_inst(), Some(inst));
-    }
-}
-
-#[cfg(not(feature = "enable-peepmatic"))]
 mod simplify {
     use super::*;
     use crate::ir::{