Factor out a MemFlags constructor for trusted notrap/aligned accesses.

lib/codegen/src/ir/memflags.rs

@@ -26,6 +26,15 @@ impl MemFlags {
         Self { bits: 0 }
     }
 
+    /// Create a set of flags representing an access from a "trusted" address, meaning it's
+    /// known to be aligned and non-trapping.
+    pub fn trusted() -> Self {
+        let mut result = Self::new();
+        result.set_notrap();
+        result.set_aligned();
+        result
+    }
+
     /// Read a flag bit.
     fn read(self, bit: FlagBit) -> bool {
         self.bits & (1 << bit as usize) != 0

lib/codegen/src/legalizer/globalvalue.rs

@@ -110,9 +110,7 @@ fn load_addr(
     };
 
     // Global-value loads are always notrap and aligned. They may be readonly.
-    let mut mflags = ir::MemFlags::new();
+    let mut mflags = ir::MemFlags::trusted();
-    mflags.set_notrap();
-    mflags.set_aligned();
     if readonly {
         mflags.set_readonly();
     }

lib/codegen/src/legalizer/mod.rs

@@ -400,10 +400,8 @@ fn expand_stack_load(
 
     let addr = pos.ins().stack_addr(addr_ty, stack_slot, offset);
 
-    let mut mflags = MemFlags::new();
     // Stack slots are required to be accessible and aligned.
-    mflags.set_notrap();
+    let mflags = MemFlags::trusted();
-    mflags.set_aligned();
     pos.func.dfg.replace(inst).load(ty, mflags, addr, 0);
 }
 

lib/wasm/src/code_translator.rs

@@ -77,9 +77,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 GlobalVariable::Const(val) => val,
                 GlobalVariable::Memory { gv, offset, ty } => {
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
-                    let mut flags = ir::MemFlags::new();
+                    let flags = ir::MemFlags::trusted();
-                    flags.set_notrap();
-                    flags.set_aligned();
                     builder.ins().load(ty, flags, addr, offset)
                 }
             };
@@ -90,9 +88,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 GlobalVariable::Const(_) => panic!("global #{} is a constant", global_index),
                 GlobalVariable::Memory { gv, offset, ty } => {
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
-                    let mut flags = ir::MemFlags::new();
+                    let flags = ir::MemFlags::trusted();
-                    flags.set_notrap();
-                    flags.set_aligned();
                     let val = state.pop1();
                     debug_assert_eq!(ty, builder.func.dfg.value_type(val));
                     builder.ins().store(flags, val, addr, offset);

lib/wasm/src/environ/dummy.rs

@@ -270,9 +270,7 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
             let ext = pos.ins().uextend(I64, callee);
             pos.ins().imul_imm(ext, 4)
         };
-        let mut mflags = ir::MemFlags::new();
+        let mflags = ir::MemFlags::trusted();
-        mflags.set_notrap();
-        mflags.set_aligned();
         let func_ptr = pos.ins().load(ptr, mflags, callee_offset, 0);
 
         // Build a value list for the indirect call instruction containing the callee, call_args,