Mark loads from globals aligned and notrap.

Mark loads from globals generated by cton_wasm or by legalization as
`aligned` and `notrap`, since memory for these globals should be
allocated by the runtime environment for that purpose. This reduces
the number of potentially trapping instructions, which can reduce
the amount of metadata required by embedding environments.

lib/cretonne/src/ir/globalvar.rs

@@ -17,7 +17,8 @@ pub enum GlobalVarData {
     /// Variable is part of a struct pointed to by another global variable.
     ///
     /// The `base` global variable is assumed to contain a pointer to a struct. This global
-    /// variable lives at an offset into the struct.
+    /// variable lives at an offset into the struct. The memory must be accessible, and
+    /// naturally aligned to hold a pointer value.
     Deref {
         /// The base pointer global variable.
         base: GlobalVar,

lib/cretonne/src/ir/heap.rs

@@ -29,7 +29,8 @@ pub enum HeapBase {
     /// This feature is not yet implemented.
     ReservedReg,
 
-    /// The heap base is in a global variable.
+    /// The heap base is in a global variable. The variable must be accessible and naturally
+    /// aligned for a pointer.
     GlobalVar(GlobalVar),
 }
 
@@ -38,7 +39,8 @@ pub enum HeapBase {
 pub enum HeapStyle {
     /// A dynamic heap can be relocated to a different base address when it is grown.
     Dynamic {
-        /// Global variable holding the current bound of the heap in bytes.
+        /// Global variable holding the current bound of the heap in bytes. It is
+        /// required to be accessible and naturally aligned for a pointer-sized integer.
         bound_gv: GlobalVar,
     },
 

lib/cretonne/src/legalizer/globalvar.rs

@@ -52,8 +52,11 @@ fn deref_addr(inst: ir::Inst, func: &mut ir::Function, base: ir::GlobalVar, offs
     pos.use_srcloc(inst);
 
     let base_addr = pos.ins().global_addr(ptr_ty, base);
-    // TODO: We could probably set both `notrap` and `aligned` on this load instruction.
-    let base_ptr = pos.ins().load(ptr_ty, ir::MemFlags::new(), base_addr, 0);
+    let mut mflags = ir::MemFlags::new();
+    // Deref globals are required to be accessible and aligned.
+    mflags.set_notrap();
+    mflags.set_aligned();
+    let base_ptr = pos.ins().load(ptr_ty, mflags, base_addr, 0);
     pos.func.dfg.replace(inst).iadd_imm(base_ptr, offset);
 }
 

lib/cretonne/src/legalizer/heap.rs

@@ -58,7 +58,11 @@ fn dynamic_addr(
 
     // Start with the bounds check. Trap if `offset + size > bound`.
     let bound_addr = pos.ins().global_addr(addr_ty, bound_gv);
-    let bound = pos.ins().load(offset_ty, MemFlags::new(), bound_addr, 0);
+    let mut mflags = MemFlags::new();
+    // The bound variable is requied to be accessible and aligned.
+    mflags.set_notrap();
+    mflags.set_aligned();
+    let bound = pos.ins().load(offset_ty, mflags, bound_addr, 0);
 
     let oob;
     if size == 1 {
@@ -175,7 +179,11 @@ fn offset_addr(
         ir::HeapBase::ReservedReg => unimplemented!(),
         ir::HeapBase::GlobalVar(base_gv) => {
             let base_addr = pos.ins().global_addr(addr_ty, base_gv);
-            let base = pos.ins().load(addr_ty, MemFlags::new(), base_addr, 0);
+            let mut mflags = MemFlags::new();
+            // The base address variable is requied to be accessible and aligned.
+            mflags.set_notrap();
+            mflags.set_aligned();
+            let base = pos.ins().load(addr_ty, mflags, base_addr, 0);
             pos.func.dfg.replace(inst).iadd(base, offset);
         }
     }