Legalize stack_store in ISLE

cranelift/codegen/meta/src/gen_inst.rs

@@ -1229,7 +1229,7 @@ impl IsleTarget {
         }
     }
     fn ignore_value_lists(&self) -> bool {
-        matches!(self, IsleTarget::Opt | IsleTarget::Legalize)
+        matches!(self, IsleTarget::Opt)
     }
     fn match_type(&self) -> bool {
         matches!(self, IsleTarget::Opt)
@@ -1627,6 +1627,9 @@ fn gen_insn_constructor(
     common_ctor: &str,
     ret_ty: &str,
 ) {
+    if inst.format.has_value_list {
+        return;
+    }
     // Generate a constructor if this is the mid-end prelude.
     let input_tys = inst
         .operands_in

cranelift/codegen/src/context.rs

@@ -290,8 +290,8 @@ impl Context {
         self.loop_analysis.clear();
 
         // Run some specific legalizations only.
-        simple_legalize(&mut self.func, &mut self.cfg, isa);
         isa.legalize_function(&mut self.func, &mut self.cfg);
+        simple_legalize(&mut self.func, &mut self.cfg, isa);
         self.verify_if(isa)
     }
 

cranelift/codegen/src/isa/riscv64/legalize.isle

@@ -26,6 +26,13 @@
 (extern constructor value_array_2_ctor value_array_2_ctor)
 (decl value_array_3_ctor (Value Value Value) ValueArray3)
 (extern constructor value_array_3_ctor value_array_3_ctor)
+(decl value_list_slice (ValueSlice) ValueList)
+(extern extractor infallible value_list_slice value_list_slice)
+(decl value_slice_unwrap (Value ValueSlice) ValueSlice)
+(extern extractor value_slice_unwrap value_slice_unwrap)
+(decl unwrap_head_value_list_1 (Value ValueSlice) ValueList)
+(extractor (unwrap_head_value_list_1 head tail)
+           (value_list_slice (value_slice_unwrap head tail)))
 
 (decl pure first_result (Inst) Value)
 (extern constructor first_result first_result)
@@ -48,6 +55,8 @@
 ;; all backends in addition to backend-specific legalization.
 (decl partial legalize (Inst) Inst)
 
+;; ========= `{u,s}extend` ====================================================
+
 ;; Transform extend-to-i128 to an `iconcat` instruction
 (rule 0 (legalize (has_type $I128 (uextend x @ (value_type (fits_in_32 _)))))
   (replace_iconcat $I64 (ins_uextend $I64 x) (ins_i64 0)))
@@ -58,3 +67,10 @@
     (replace_iconcat $I64 val64 (ins_sshr $I64 val64 (ins_i64 63)))))
 (rule 1 (legalize (has_type $I128 (sextend x @ (value_type $I64))))
   (replace_iconcat $I64 x (ins_sshr $I64 x (ins_i64 63))))
+
+;; ========= `stack_store` ====================================================
+
+;; stack_store(val, slot, offset) => store(val, stack_addr(slot, offset), 0)
+(rule (legalize (stack_store val @ (value_type ty) slot offset))
+  (let ((addr Value (ins_stack_addr $I64 slot offset)))
+    (replace_store ty (mem_flags_notrap) val addr (i32_to_offset32 0))))

cranelift/codegen/src/isa/riscv64/legalize.rs

@@ -77,6 +77,19 @@ impl generated::Context for Legalize<'_> {
         }
     }
 
+    fn value_list_slice(&mut self, list: ValueList) -> ValueSlice {
+        (list, 0)
+    }
+
+    fn value_slice_unwrap(&mut self, slice: ValueSlice) -> Option<(Value, ValueSlice)> {
+        let (list, off) = slice;
+        if let Some(val) = list.get(off, &self.pos.func.dfg.value_lists) {
+            Some((val, (list, off + 1)))
+        } else {
+            None
+        }
+    }
+
     fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2 {
         [arg0, arg1]
     }

cranelift/codegen/src/isle_prelude.rs

@@ -828,6 +828,12 @@ macro_rules! isle_common_prelude_methods {
             MemFlags::trusted()
         }
 
+        fn mem_flags_notrap(&mut self) -> MemFlags {
+            let mut mflags = MemFlags::new();
+            mflags.set_notrap();
+            mflags
+        }
+
         #[inline]
         fn intcc_unsigned(&mut self, x: &IntCC) -> IntCC {
             x.unsigned()

cranelift/codegen/src/prelude.isle

@@ -337,6 +337,10 @@
 (decl pure mem_flags_trusted () MemFlags)
 (extern constructor mem_flags_trusted mem_flags_trusted)
 
+;; `MemFlags::notrap`
+(decl pure mem_flags_notrap () MemFlags)
+(extern constructor mem_flags_notrap mem_flags_notrap)
+
 ;;;; Helpers for Working with Flags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Swap args of an IntCC flag.