Cranelift: simplify some side-effectful instructions in ISLE (#10524)

* Cranelift: simplify some side-effectful instructions in ISLE

This commit adds a new top-level ISLE entrypoint specifically for instructions
in the side-effectful skeleton: `simplify_skeleton`. While these rewrites are
processed during the egraph pass, values from skeleton instructions still do not
get inserted into the egraph. Indeed, `simplify_skeleton` operates
on *instructions* rather than *values* because we do not represent side effects
as values; values do not have side effects in CLIF, instructions do. Therefore,
rather than doing a whole dynamic-programming style extraction of the best
candidate simplification like we do with the egraph, we take an eager and greedy
approach.

Furthermore, `simplify_skeleton` is limited only to skeleton instructions that
do not involve control-flow or terminators right now. This is because changing
the control-flow graph can change whether a use is dominated by a def or not,
and we do not currently have the machinery to track and fix up invalidated
uses. Addressing this is left for future commits.

* fix `MIN / -1` cprop and add negative tests for things simplify_skeleton cannot handle yet

Author: fitzgen

cranelift/codegen/meta/src/gen_isle.rs

@@ -208,25 +208,26 @@ fn gen_common_isle(
         ";;;; Extracting Opcode, Operands, and Immediates from `InstructionData` ;;;;;;;;",
     );
     fmt.empty_line();
-    let ret_ty = match isle_target {
-        IsleTarget::Lower => "Inst",
-        IsleTarget::Opt => "Value",
-    };
     for inst in instructions {
-        if isle_target == IsleTarget::Opt
-            && (inst.format.has_value_list || inst.value_results.len() != 1)
-        {
-            continue;
-        }
+        let results_len = inst.value_results.len();
+        let is_var_args = inst.format.has_value_list;
+        let has_side_effects = inst.can_trap || inst.other_side_effects;
+
+        let (ret_ty, ty_in_decl, make_inst_ctor, inst_data_etor) =
+            match (isle_target, is_var_args, results_len, has_side_effects) {
+                // The mid-end does not deal with instructions that have var-args right now.
+                (IsleTarget::Opt, true, _, _) => continue,
+
+                (IsleTarget::Opt, _, 1, false) => ("Value", true, "make_inst", "inst_data_value"),
+                (IsleTarget::Opt, _, _, _) => ("Inst", false, "make_skeleton_inst", "inst_data"),
+                (IsleTarget::Lower, _, _, _) => ("Inst", false, "make_inst", "inst_data_value"),
+            };
 
         fmtln!(
             fmt,
             "(decl {} ({}{}) {})",
             inst.name,
-            match isle_target {
-                IsleTarget::Lower => "",
-                IsleTarget::Opt => "Type ",
-            },
+            if ty_in_decl { "Type " } else { "" },
             inst.operands_in
                 .iter()
                 .map(|o| {
@@ -247,10 +248,7 @@ fn gen_common_isle(
                 fmt,
                 "({} {}{})",
                 inst.name,
-                match isle_target {
-                    IsleTarget::Lower => "",
-                    IsleTarget::Opt => "ty ",
-                },
+                if ty_in_decl { "ty " } else { "" },
                 inst.operands_in
                     .iter()
                     .map(|o| { o.name })
@@ -259,11 +257,8 @@ fn gen_common_isle(
             );
 
             let mut s = format!(
-                "(inst_data{} (InstructionData.{} (Opcode.{})",
-                match isle_target {
-                    IsleTarget::Lower => "",
-                    IsleTarget::Opt => " ty",
-                },
+                "({inst_data_etor} {}(InstructionData.{} (Opcode.{})",
+                if ty_in_decl { "ty " } else { "" },
                 inst.format.name,
                 inst.camel_name
             );
@@ -367,8 +362,9 @@ fn gen_common_isle(
         if isle_target == IsleTarget::Opt {
             fmtln!(
                 fmt,
-                "(rule ({} ty {})",
+                "(rule ({}{} {})",
                 inst.name,
+                if ty_in_decl { " ty" } else { "" },
                 inst.operands_in
                     .iter()
                     .map(|o| o.name)
@@ -377,8 +373,10 @@ fn gen_common_isle(
             );
             fmt.indent(|fmt| {
                 let mut s = format!(
-                    "(make_inst ty (InstructionData.{} (Opcode.{})",
-                    inst.format.name, inst.camel_name
+                    "({make_inst_ctor}{} (InstructionData.{} (Opcode.{})",
+                    if ty_in_decl { " ty" } else { "" },
+                    inst.format.name,
+                    inst.camel_name
                 );
 
                 // Handle values. Note that we skip generating

cranelift/codegen/meta/src/isle.rs

@@ -111,6 +111,7 @@ pub fn get_isle_compilations(
                     src_opts.join("remat.isle"),
                     src_opts.join("selects.isle"),
                     src_opts.join("shifts.isle"),
+                    src_opts.join("skeleton.isle"),
                     src_opts.join("spaceship.isle"),
                     src_opts.join("spectre.isle"),
                     src_opts.join("vector.isle"),

cranelift/codegen/src/cursor.rs

@@ -531,6 +531,17 @@ pub trait Cursor {
         inst
     }
 
+    /// Replace the instruction under the cursor with `new_inst`.
+    ///
+    /// The cursor is left pointing at the new instruction.
+    ///
+    /// The old instruction that was replaced is returned.
+    fn replace_inst(&mut self, new_inst: ir::Inst) -> ir::Inst {
+        let prev_inst = self.remove_inst();
+        self.insert_inst(new_inst);
+        prev_inst
+    }
+
     /// Insert a block at the current position and switch to it.
     ///
     /// As far as possible, this method behaves as if the block header were an instruction inserted