Rename pure flag to can_move

Author: fitzgen

cranelift/codegen/src/inst_predicates.rs

@@ -41,15 +41,15 @@ fn has_side_effect(func: &Function, inst: Inst) -> bool {
 /// Does the given instruction behave as a "pure" node with respect to
 /// aegraph semantics?
 ///
-/// - Actual pure nodes (arithmetic, etc)
-/// - Loads with the `readonly`, `notrap`, and `pure` flags set
+/// - Trivially pure nodes (bitwise arithmetic, etc)
+/// - Loads with the `readonly`, `notrap`, and `can_move` flags set
 pub fn is_pure_for_egraph(func: &Function, inst: Inst) -> bool {
-    let is_readonly_load = match func.dfg.insts[inst] {
+    let is_pure_load = match func.dfg.insts[inst] {
         InstructionData::Load {
             opcode: Opcode::Load,
             flags,
             ..
-        } => flags.readonly() && flags.notrap() && flags.pure(),
+        } => flags.readonly() && flags.notrap() && flags.can_move(),
         _ => false,
     };
 
@@ -65,7 +65,7 @@ pub fn is_pure_for_egraph(func: &Function, inst: Inst) -> bool {
 
     let op = func.dfg.insts[inst].opcode();
 
-    has_one_result && (is_readonly_load || (!op.can_load() && !trivially_has_side_effects(op)))
+    has_one_result && (is_pure_load || (!op.can_load() && !trivially_has_side_effects(op)))
 }
 
 /// Can the given instruction be merged into another copy of itself?

cranelift/codegen/src/ir/memflags.rs

@@ -73,7 +73,7 @@ pub struct MemFlags {
     // * 4 - checked flag
     // * 5/6 - alias region
     // * 7/8/9/10/11/12/13/14 - trap code
-    // * 15 - pure flag
+    // * 15 - can_move flag
     //
     // Current properties upheld are:
     //
@@ -112,11 +112,12 @@ const ALIAS_REGION_OFFSET: u16 = 5;
 const MASK_TRAP_CODE: u16 = 0b1111_1111 << TRAP_CODE_OFFSET;
 const TRAP_CODE_OFFSET: u16 = 7;
 
-/// Whether the load's/store's safety is purely a function of its data
-/// dependencies (i.e. operands) and is not guarded by
-/// outside-the-data-flow-graph properties, like implicit bounds-checking
+/// Whether this memory operation may be freely moved by the optimizer so long
+/// as its data dependencies are satisfied. That is, by setting this flag, the
+/// producer is guaranteeing that this memory operation's safety is not guarded
+/// by outside-the-data-flow-graph properties, like implicit bounds-checking
 /// control dependencies.
-const BIT_PURE: u16 = 1 << 15;
+const BIT_CAN_MOVE: u16 = 1 << 15;
 
 impl MemFlags {
     /// Create a new empty set of flags.
@@ -204,7 +205,7 @@ impl MemFlags {
                 self.with_alias_region(Some(AliasRegion::Vmctx))
             }
             "checked" => self.with_checked(),
-            "pure" => self.with_pure(),
+            "can_move" => self.with_can_move(),
 
             other => match TrapCode::from_str(other) {
                 Ok(code) => self.with_trap_code(Some(code)),
@@ -272,7 +273,7 @@ impl MemFlags {
     /// This flag does *not* mean that the associated instruction can be
     /// code-motioned to arbitrary places in the function so long as its data
     /// dependencies are met. This only means that, given its current location
-    /// in the function, it will never trap. See the `pure` method for more
+    /// in the function, it will never trap. See the `can_move` method for more
     /// details.
     pub const fn notrap(self) -> bool {
         self.trap_code().is_none()
@@ -289,8 +290,8 @@ impl MemFlags {
         self.with_trap_code(None)
     }
 
-    /// Is this memory operation's safety (e.g. the validity of its `notrap` and
-    /// `readonly` claims) purely a function of its data dependencies?
+    /// Is this memory operation safe to move so long as its data dependencies
+    /// remain satisfied?
     ///
     /// If this is `true`, then it is okay to code motion this instruction to
     /// arbitrary locations, in the function, including across blocks and
@@ -304,18 +305,18 @@ impl MemFlags {
     /// bounds check, which is not reflected in its operands, and it would be
     /// unsafe to code motion it above the bounds check, even if its data
     /// dependencies would still be satisfied.
-    pub const fn pure(self) -> bool {
-        self.read_bit(BIT_PURE)
+    pub const fn can_move(self) -> bool {
+        self.read_bit(BIT_CAN_MOVE)
     }
 
-    /// Set the `pure` flag.
-    pub const fn set_pure(&mut self) {
-        *self = self.with_pure();
+    /// Set the `can_move` flag.
+    pub const fn set_can_move(&mut self) {
+        *self = self.with_can_move();
     }
 
-    /// Set the `pure` flag, returning new flags.
-    pub const fn with_pure(self) -> Self {
-        self.with_bit(BIT_PURE)
+    /// Set the `can_move` flag, returning new flags.
+    pub const fn with_can_move(self) -> Self {
+        self.with_bit(BIT_CAN_MOVE)
     }
 
     /// Test if the `aligned` flag is set.
@@ -424,8 +425,8 @@ impl fmt::Display for MemFlags {
         if self.readonly() {
             write!(f, " readonly")?;
         }
-        if self.pure() {
-            write!(f, " pure")?;
+        if self.can_move() {
+            write!(f, " can_move")?;
         }
         if self.read_bit(BIT_BIG_ENDIAN) {
             write!(f, " big")?;

cranelift/filetests/filetests/egraph/load-hoist.clif

@@ -2,7 +2,7 @@ test optimize
 set opt_level=speed_and_size
 target x86_64
 
-function %pure_hoists(i64 vmctx, i64, i32, i32) -> i32 fast {
+function %can_move_hoists(i64 vmctx, i64, i32, i32) -> i32 fast {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned readonly gv0+8
     gv2 = load.i64 notrap aligned gv1
@@ -15,7 +15,7 @@ function %pure_hoists(i64 vmctx, i64, i32, i32) -> i32 fast {
         jump block2(v5, v2, v3)  ; v5 = 0
 
     block2(v6: i32, v7: i32, v15: i32):
-        v9 = load.i64 notrap aligned readonly pure v0+80
+        v9 = load.i64 notrap aligned readonly can_move v0+80
         v8 = uextend.i64 v7
         v10 = iadd v9, v8
         v11 = load.i32 little heap v10
@@ -37,13 +37,13 @@ function %pure_hoists(i64 vmctx, i64, i32, i32) -> i32 fast {
         return v12
 }
 
-; check:    v9 = load.i64 notrap aligned readonly pure v0+80
+; check:    v9 = load.i64 notrap aligned readonly can_move v0+80
 ; check: block2(v6: i32, v7: i32, v15: i32):
 ; check:    v10 = iadd.i64 v9, v8
 ; check:    v11 = load.i32 little heap v10
 ; check:    brif v19, block2(v12, v21, v19), block4
 
-function %non_pure_does_not_hoist(i64 vmctx, i64, i32, i32) -> i32 fast {
+function %non_can_move_does_not_hoist(i64 vmctx, i64, i32, i32) -> i32 fast {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned readonly gv0+8
     gv2 = load.i64 notrap aligned gv1

crates/cranelift/src/func_environ.rs

@@ -298,7 +298,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                 base: vmctx,
                 offset: Offset32::new(i32::try_from(from_offset).unwrap()),
                 global_type: pointer_type,
-                flags: MemFlags::trusted().with_readonly().with_pure(),
+                flags: MemFlags::trusted().with_readonly().with_can_move(),
             });
             (global, 0)
         }
@@ -316,7 +316,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         debug_assert!(self.vmstore_context_ptr.is_reserved_value());
         self.vmstore_context_ptr = builder.ins().load(
             pointer_type,
-            ir::MemFlags::trusted().with_readonly().with_pure(),
+            ir::MemFlags::trusted().with_readonly().with_can_move(),
             base,
             offset,
         );
@@ -810,7 +810,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                     base: vmctx,
                     offset: Offset32::new(i32::try_from(from_offset).unwrap()),
                     global_type: pointer_type,
-                    flags: MemFlags::trusted().with_readonly().with_pure(),
+                    flags: MemFlags::trusted().with_readonly().with_can_move(),
                 });
                 let base_offset = i32::from(self.offsets.vmtable_definition_base());
                 let current_elements_offset =
@@ -834,7 +834,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             flags: if Some(table.limits.min) == table.limits.max {
                 // A fixed-size table can't be resized so its base address won't
                 // change.
-                MemFlags::trusted().with_readonly().with_pure()
+                MemFlags::trusted().with_readonly().with_can_move()
             } else {
                 MemFlags::trusted()
             },
@@ -1021,7 +1021,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             base: vmctx,
             offset: Offset32::new(i32::try_from(offset).unwrap()),
             global_type: self.pointer_type(),
-            flags: MemFlags::trusted().with_readonly().with_pure(),
+            flags: MemFlags::trusted().with_readonly().with_can_move(),
         });
 
         let mt = memtype.map(|mt| {
@@ -1155,7 +1155,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
     ) -> ir::Value {
         let vmctx = self.vmctx_val(pos);
         let pointer_type = self.pointer_type();
-        let mem_flags = ir::MemFlags::trusted().with_readonly().with_pure();
+        let mem_flags = ir::MemFlags::trusted().with_readonly().with_can_move();
 
         // Load the base pointer of the array of `VMSharedTypeIndex`es.
         let shared_indices = pos.ins().load(
@@ -1272,7 +1272,7 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
         let vmctx = self.env.vmctx(self.builder.func);
         let base = self.builder.ins().global_value(pointer_type, vmctx);
 
-        let mem_flags = ir::MemFlags::trusted().with_readonly().with_pure();
+        let mem_flags = ir::MemFlags::trusted().with_readonly().with_can_move();
 
         // Load the callee address.
         let body_offset = i32::try_from(
@@ -2277,7 +2277,7 @@ impl FuncEnvironment<'_> {
             if global_ty.mutability {
                 ir::MemFlags::trusted()
             } else {
-                ir::MemFlags::trusted().with_readonly().with_pure()
+                ir::MemFlags::trusted().with_readonly().with_can_move()
             },
         )
     }
@@ -2480,7 +2480,7 @@ impl FuncEnvironment<'_> {
             }
         };
 
-        let mut flags = MemFlags::trusted().with_checked().with_pure();
+        let mut flags = MemFlags::trusted().with_checked().with_can_move();
         if !memory.memory_may_move(self.tunables) {
             flags.set_readonly();
         }

crates/cranelift/src/gc/enabled.rs

@@ -1244,7 +1244,7 @@ impl FuncEnvironment<'_> {
     /// Get the GC heap's base pointer.
     fn get_gc_heap_base(&mut self, builder: &mut FunctionBuilder) -> ir::Value {
         let ptr_ty = self.pointer_type();
-        let flags = ir::MemFlags::trusted().with_readonly().with_pure();
+        let flags = ir::MemFlags::trusted().with_readonly().with_can_move();
 
         let vmctx = self.vmctx(builder.func);
         let vmctx = builder.ins().global_value(ptr_ty, vmctx);
@@ -1258,7 +1258,7 @@ impl FuncEnvironment<'_> {
     /// Get the GC heap's bound.
     fn get_gc_heap_bound(&mut self, builder: &mut FunctionBuilder) -> ir::Value {
         let ptr_ty = self.pointer_type();
-        let flags = ir::MemFlags::trusted().with_readonly().with_pure();
+        let flags = ir::MemFlags::trusted().with_readonly().with_can_move();
 
         let vmctx = self.vmctx(builder.func);
         let vmctx = builder.ins().global_value(ptr_ty, vmctx);

tests/disas/basic-wat-test.wat

@@ -15,16 +15,16 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned readonly pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned readonly can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
 ;; @0021                               v5 = uextend.i64 v2
-;; @0021                               v6 = load.i64 notrap aligned readonly pure checked v0+88
+;; @0021                               v6 = load.i64 notrap aligned readonly can_move checked v0+88
 ;; @0021                               v7 = iadd v6, v5
 ;; @0021                               v8 = load.i32 little heap v7
 ;; @0026                               v9 = uextend.i64 v3
-;; @0026                               v10 = load.i64 notrap aligned readonly pure checked v0+88
+;; @0026                               v10 = load.i64 notrap aligned readonly can_move checked v0+88
 ;; @0026                               v11 = iadd v10, v9
 ;; @0026                               v12 = load.i32 little heap v11
 ;; @0029                               v13 = iadd v8, v12

tests/disas/duplicate-loads-dynamic-memory.wat

@@ -28,12 +28,12 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0057                               v6 = load.i64 notrap aligned v0+96
-;; @0057                               v8 = load.i64 notrap aligned pure checked v0+88
+;; @0057                               v8 = load.i64 notrap aligned can_move checked v0+88
 ;; @0057                               v5 = uextend.i64 v2
 ;; @0057                               v7 = icmp ugt v5, v6
 ;; @0057                               v10 = iconst.i64 0
@@ -52,12 +52,12 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0064                               v6 = load.i64 notrap aligned v0+96
-;; @0064                               v8 = load.i64 notrap aligned pure checked v0+88
+;; @0064                               v8 = load.i64 notrap aligned can_move checked v0+88
 ;; @0064                               v5 = uextend.i64 v2
 ;; @0064                               v7 = icmp ugt v5, v6
 ;; @0064                               v12 = iconst.i64 0

tests/disas/duplicate-loads-static-memory.wat

@@ -23,11 +23,11 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned readonly pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned readonly can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
-;; @0057                               v6 = load.i64 notrap aligned readonly pure checked v0+88
+;; @0057                               v6 = load.i64 notrap aligned readonly can_move checked v0+88
 ;; @0057                               v5 = uextend.i64 v2
 ;; @0057                               v7 = iadd v6, v5
 ;; @0057                               v8 = load.i32 little heap v7
@@ -43,11 +43,11 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned readonly pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned readonly can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
-;; @0064                               v6 = load.i64 notrap aligned readonly pure checked v0+88
+;; @0064                               v6 = load.i64 notrap aligned readonly can_move checked v0+88
 ;; @0064                               v5 = uextend.i64 v2
 ;; @0064                               v7 = iadd v6, v5
 ;; @0064                               v8 = iconst.i64 1234

tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat

@@ -41,15 +41,15 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0047                               v7 = load.i64 notrap aligned v0+96
 ;; @0047                               v6 = uextend.i64 v2
 ;; @0047                               v8 = icmp ugt v6, v7
 ;; @0047                               trapnz v8, heap_oob
-;; @0047                               v9 = load.i64 notrap aligned pure checked v0+88
+;; @0047                               v9 = load.i64 notrap aligned can_move checked v0+88
 ;; @0047                               v10 = iadd v9, v6
 ;; @0047                               v11 = load.i32 little heap v10
 ;; @004c                               v17 = iconst.i64 4
@@ -74,15 +74,15 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @005d                               v7 = load.i64 notrap aligned v0+96
 ;; @005d                               v6 = uextend.i64 v2
 ;; @005d                               v8 = icmp ugt v6, v7
 ;; @005d                               trapnz v8, heap_oob
-;; @005d                               v9 = load.i64 notrap aligned pure checked v0+88
+;; @005d                               v9 = load.i64 notrap aligned can_move checked v0+88
 ;; @005d                               v10 = iadd v9, v6
 ;; @005d                               store little heap v3, v10
 ;; @0064                               v16 = iconst.i64 4

tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat

@@ -37,12 +37,12 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32):
 ;; @0047                               v7 = load.i64 notrap aligned v0+96
-;; @0047                               v9 = load.i64 notrap aligned pure checked v0+88
+;; @0047                               v9 = load.i64 notrap aligned can_move checked v0+88
 ;; @0047                               v6 = uextend.i64 v2
 ;; @0047                               v8 = icmp ugt v6, v7
 ;; @0047                               v11 = iconst.i64 0
@@ -72,12 +72,12 @@
 ;;     gv2 = load.i64 notrap aligned gv1+16
 ;;     gv3 = vmctx
 ;;     gv4 = load.i64 notrap aligned gv3+96
-;;     gv5 = load.i64 notrap aligned pure checked gv3+88
+;;     gv5 = load.i64 notrap aligned can_move checked gv3+88
 ;;     stack_limit = gv2
 ;;
 ;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
 ;; @005d                               v7 = load.i64 notrap aligned v0+96
-;; @005d                               v9 = load.i64 notrap aligned pure checked v0+88
+;; @005d                               v9 = load.i64 notrap aligned can_move checked v0+88
 ;; @005d                               v6 = uextend.i64 v2
 ;; @005d                               v8 = icmp ugt v6, v7
 ;; @005d                               v11 = iconst.i64 0