[WebAssembly] Refactor load ISel tablegen patterns into classes

[dschuff]

Summary

Not all of these will be able to be used by atomics because tablegen, but it
still seems like a good change by itself.

[jgravelle-google]

As an overall comment, this is awesome. Big fan of reducing syntactic noise.

lib/Target/WebAssembly/WebAssemblyInstrAtomics.td

27 ↗

(On Diff #113438)

Is this actually different from LoadPatNoOffset? I'd think you could pass load or atomic_load as the node parameter and it should work either way.

34 ↗

(On Diff #113438)

These look like they could use an ALoadPatImmOff

Also technically this is defining additional patterns, and isn't covered by the commit message. I'm ok with that though.

48 ↗

(On Diff #113438)

What are these non-atomic loads doing here? Also aren't these already represented in WebAssemblyInstrMemory.td?

[dschuff]

lib/Target/WebAssembly/WebAssemblyInstrAtomics.td

27 ↗

(On Diff #113438)

Alas... you'd think so. I certainly thought so. However I tried it, and then I read include/llvm/Target/TargetSelectionDAG.td and found that load (and the extending loads) are actually PatFrags, while the atomic loads are SDNodes, so they can't be freely mixed in templates like that. I feel like you could maybe make a PatFrag to wrap around the atomic loads and then use the other classes, but I don't know how to do that yet. Perhaps I'll try but I don't know whether it will be worth it or not, especially given we'll have different rules for selecting extending loads anyway (since there are no extending atomic loads), and that there are only 2 types instead of 4. So we'll see when we get more concrete about all of that.

34 ↗

(On Diff #113438)

Ah yeah. I had actually intended to back this part of the CL out once I got deep enough into refactoring the other td file. I'll do that.

48 ↗

(On Diff #113438)

Yeah this is just a paste that I had before I got down the other rabbit hole. will remove it too.

[dschuff]

• address comments: remove atomic rules with constant offsets

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Atomic loads
 //===----------------------------------------------------------------------===//
 
 let Defs = [ARGUMENTS] in {
 // TODO: add the rest of the atomic loads
-// TODO: factor out 0xfe atomic prefix?
-def ATOMIC_LOAD_I32 : ATOMIC_I<(outs I32:$dst),
-                        (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
-                        [], "i32.atomic.load\t$dst, ${off}(${addr})${p2align}",
-                        0xfe10>;
+def ATOMIC_LOAD_I32 : CLoadI32<"i32.atomic.load", 0xfe10>;
+def ATOMIC_LOAD_I64 : CLoadI64<"i64.atomic.load", 0xfe11>;
 } // Defs = [ARGUMENTS]
 
 // Select loads with no constant offset.
 let Predicates = [HasAtomics] in {
-def : Pat<(i32 (atomic_load I32:$addr)), (ATOMIC_LOAD_I32 0, 0, $addr)>;
+class ALoadPatNoOffset<ValueType ty, SDNode node, I inst> :
+  Pat<(ty (node I32:$addr)), (inst 0, 0, $addr)>;
+def : ALoadPatNoOffset<i32, atomic_load, ATOMIC_LOAD_I32>;
+def : ALoadPatNoOffset<i64, atomic_load, ATOMIC_LOAD_I64>;
+
 }
 
 //===----------------------------------------------------------------------===//
 // Atomic stores
 //===----------------------------------------------------------------------===//
 
 // TODO: add atomic stores here...
 

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrMemory.td

def regPlusGA : PatFrag<(ops node:$addr, node:$off),
   return N->getFlags().hasNoUnsignedWrap();
 }]>;
 
 // We don't need a regPlusES because external symbols never have constant
 // offsets folded into them, so we can just use add.
 
 let Defs = [ARGUMENTS] in {
 
+// Classes to define both atomic and non-atomic integer loads
+class CLoadI32<string Name, int Opcode> :
+  I<(outs I32:$dst),
+    (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
+    [], !strconcat(Name, "\t$dst, ${off}(${addr})${p2align}"), Opcode>;
+
+class CLoadI64<string Name, int Opcode> :
+  I<(outs I64:$dst),
+    (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
+    [], !strconcat(Name, "\t$dst, ${off}(${addr})${p2align}"), Opcode>;
+
 // Basic load.
 // FIXME: When we can break syntax compatibility, reorder the fields in the
 // asmstrings to match the binary encoding.
-def LOAD_I32 : I<(outs I32:$dst),
-                 (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
-                 [], "i32.load\t$dst, ${off}(${addr})${p2align}", 0x28>;
-def LOAD_I64 : I<(outs I64:$dst),
-                 (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
-                 [], "i64.load\t$dst, ${off}(${addr})${p2align}", 0x29>;
+def LOAD_I32 : CLoadI32<"i32.load", 0x28>;
+def LOAD_I64 : CLoadI64<"i64.load", 0x29>;
 def LOAD_F32 : I<(outs F32:$dst),
                  (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
                  [], "f32.load\t$dst, ${off}(${addr})${p2align}", 0x2a>;
 def LOAD_F64 : I<(outs F64:$dst),
                  (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
                  [], "f64.load\t$dst, ${off}(${addr})${p2align}", 0x2b>;
 
 } // Defs = [ARGUMENTS]
 
 // Select loads with no constant offset.
-def : Pat<(i32 (load I32:$addr)), (LOAD_I32 0, 0, $addr)>;
-def : Pat<(i64 (load I32:$addr)), (LOAD_I64 0, 0, $addr)>;
-def : Pat<(f32 (load I32:$addr)), (LOAD_F32 0, 0, $addr)>;
-def : Pat<(f64 (load I32:$addr)), (LOAD_F64 0, 0, $addr)>;
+class LoadPatNoOffset<ValueType ty, PatFrag node, I inst> :
+  Pat<(ty (node I32:$addr)), (inst 0, 0, $addr)>;
+
+def : LoadPatNoOffset<i32, load, LOAD_I32>;
+def : LoadPatNoOffset<i64, load, LOAD_I64>;
+def : LoadPatNoOffset<f32, load, LOAD_F32>;
+def : LoadPatNoOffset<f64, load, LOAD_F64>;
+
 
 // Select loads with a constant offset.
-def : Pat<(i32 (load (regPlusImm I32:$addr, imm:$off))),
-          (LOAD_I32 0, imm:$off, $addr)>;
-def : Pat<(i64 (load (regPlusImm I32:$addr, imm:$off))),
-          (LOAD_I64 0, imm:$off, $addr)>;
-def : Pat<(f32 (load (regPlusImm I32:$addr, imm:$off))),
-          (LOAD_F32 0, imm:$off, $addr)>;
-def : Pat<(f64 (load (regPlusImm I32:$addr, imm:$off))),
-          (LOAD_F64 0, imm:$off, $addr)>;
-def : Pat<(i32 (load (or_is_add I32:$addr, imm:$off))),
-          (LOAD_I32 0, imm:$off, $addr)>;
-def : Pat<(i64 (load (or_is_add I32:$addr, imm:$off))),
-          (LOAD_I64 0, imm:$off, $addr)>;
-def : Pat<(f32 (load (or_is_add I32:$addr, imm:$off))),
-          (LOAD_F32 0, imm:$off, $addr)>;
-def : Pat<(f64 (load (or_is_add I32:$addr, imm:$off))),
-          (LOAD_F64 0, imm:$off, $addr)>;
-def : Pat<(i32 (load (regPlusGA I32:$addr,
-                                (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (load (regPlusGA I32:$addr,
-                                (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(f32 (load (regPlusGA I32:$addr,
-                                (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD_F32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(f64 (load (regPlusGA I32:$addr,
-                                (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD_F64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(f32 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD_F32 0, texternalsym:$off, $addr)>;
-def : Pat<(f64 (load (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD_F64 0, texternalsym:$off, $addr)>;
+
+// Pattern with address + immediate offset
+class LoadPatImmOff<ValueType ty, PatFrag loadkind, PatFrag operand, I inst> :
+  Pat<(ty (loadkind (operand I32:$addr, imm:$off))),
+      (inst 0, imm:$off, $addr)>;
+
+def : LoadPatImmOff<i32, load, regPlusImm, LOAD_I32>;
+def : LoadPatImmOff<i64, load, regPlusImm, LOAD_I64>;
+def : LoadPatImmOff<f32, load, regPlusImm, LOAD_F32>;
+def : LoadPatImmOff<f64, load, regPlusImm, LOAD_F64>;
+def : LoadPatImmOff<i32, load, or_is_add, LOAD_I32>;
+def : LoadPatImmOff<i64, load, or_is_add, LOAD_I64>;
+def : LoadPatImmOff<f32, load, or_is_add, LOAD_F32>;
+def : LoadPatImmOff<f64, load, or_is_add, LOAD_F64>;
+
+class LoadPatGlobalAddr<ValueType ty, PatFrag loadkind, I inst> :
+  Pat<(ty (loadkind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))),
+      (inst 0, tglobaladdr:$off, $addr)>;
+
+def : LoadPatGlobalAddr<i32, load, LOAD_I32>;
+def : LoadPatGlobalAddr<i64, load, LOAD_I64>;
+def : LoadPatGlobalAddr<f32, load, LOAD_F32>;
+def : LoadPatGlobalAddr<f64, load, LOAD_F64>;
+
+class LoadPatExternalSym<ValueType ty, PatFrag loadkind, I inst> :
+  Pat<(ty (loadkind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),
+      (inst 0, texternalsym:$off, $addr)>;
+def : LoadPatExternalSym<i32, load, LOAD_I32>;
+def : LoadPatExternalSym<i64, load, LOAD_I64>;
+def : LoadPatExternalSym<f32, load, LOAD_F32>;
+def : LoadPatExternalSym<f64, load, LOAD_F64>;
+
 
 // Select loads with just a constant offset.
-def : Pat<(i32 (load imm:$off)), (LOAD_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (load imm:$off)), (LOAD_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(f32 (load imm:$off)), (LOAD_F32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(f64 (load imm:$off)), (LOAD_F64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (load (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (load (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(f32 (load (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD_F32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(f64 (load (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD_F64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (load (WebAssemblywrapper texternalsym:$off))),
-          (LOAD_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (load (WebAssemblywrapper texternalsym:$off))),
-          (LOAD_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(f32 (load (WebAssemblywrapper texternalsym:$off))),
-          (LOAD_F32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(f64 (load (WebAssemblywrapper texternalsym:$off))),
-          (LOAD_F64 0, texternalsym:$off, (CONST_I32 0))>;
+class LoadPatOffsetOnly<ValueType ty, PatFrag loadkind, I inst> :
+  Pat<(ty (loadkind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>;
+
+def : LoadPatOffsetOnly<i32, load, LOAD_I32>;
+def : LoadPatOffsetOnly<i64, load, LOAD_I64>;
+def : LoadPatOffsetOnly<f32, load, LOAD_F32>;
+def : LoadPatOffsetOnly<f64, load, LOAD_F64>;
+
+class LoadPatGlobalAddrOffOnly<ValueType ty, PatFrag loadkind, I inst> :
+  Pat<(ty (loadkind (WebAssemblywrapper tglobaladdr:$off))),
+      (inst 0, tglobaladdr:$off, (CONST_I32 0))>;
+
+def : LoadPatGlobalAddrOffOnly<i32, load, LOAD_I32>;
+def : LoadPatGlobalAddrOffOnly<i64, load, LOAD_I64>;
+def : LoadPatGlobalAddrOffOnly<f32, load, LOAD_F32>;
+def : LoadPatGlobalAddrOffOnly<f64, load, LOAD_F64>;
+
+class LoadPatExternSymOffOnly<ValueType ty, PatFrag loadkind, I inst> :
+  Pat<(ty (loadkind (WebAssemblywrapper texternalsym:$off))),
+      (inst 0, texternalsym:$off, (CONST_I32 0))>;
+def : LoadPatExternSymOffOnly<i32, load, LOAD_I32>;
+def : LoadPatExternSymOffOnly<i64, load, LOAD_I64>;
+def : LoadPatExternSymOffOnly<f32, load, LOAD_F32>;
+def : LoadPatExternSymOffOnly<f64, load, LOAD_F64>;
 
 let Defs = [ARGUMENTS] in {
 
 // Extending load.
 def LOAD8_S_I32  : I<(outs I32:$dst),
                      (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
                      [], "i32.load8_s\t$dst, ${off}(${addr})${p2align}", 0x2c>;
 def LOAD8_U_I32  : I<(outs I32:$dst),
def LOAD32_S_I64 : I<(outs I64:$dst),
                      [], "i64.load32_s\t$dst, ${off}(${addr})${p2align}", 0x34>;
 def LOAD32_U_I64 : I<(outs I64:$dst),
                      (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
                      [], "i64.load32_u\t$dst, ${off}(${addr})${p2align}", 0x35>;
 
 } // Defs = [ARGUMENTS]
 
 // Select extending loads with no constant offset.
-def : Pat<(i32 (sextloadi8 I32:$addr)), (LOAD8_S_I32 0, 0, $addr)>;
-def : Pat<(i32 (zextloadi8 I32:$addr)), (LOAD8_U_I32 0, 0, $addr)>;
-def : Pat<(i32 (sextloadi16 I32:$addr)), (LOAD16_S_I32 0, 0, $addr)>;
-def : Pat<(i32 (zextloadi16 I32:$addr)), (LOAD16_U_I32 0, 0, $addr)>;
-def : Pat<(i64 (sextloadi8 I32:$addr)), (LOAD8_S_I64 0, 0, $addr)>;
-def : Pat<(i64 (zextloadi8 I32:$addr)), (LOAD8_U_I64 0, 0, $addr)>;
-def : Pat<(i64 (sextloadi16 I32:$addr)), (LOAD16_S_I64 0, 0, $addr)>;
-def : Pat<(i64 (zextloadi16 I32:$addr)), (LOAD16_U_I64 0, 0, $addr)>;
-def : Pat<(i64 (sextloadi32 I32:$addr)), (LOAD32_S_I64 0, 0, $addr)>;
-def : Pat<(i64 (zextloadi32 I32:$addr)), (LOAD32_U_I64 0, 0, $addr)>;
+def : LoadPatNoOffset<i32, sextloadi8, LOAD8_S_I32>;
+def : LoadPatNoOffset<i32, zextloadi8, LOAD8_U_I32>;
+def : LoadPatNoOffset<i32, sextloadi16, LOAD16_S_I32>;
+def : LoadPatNoOffset<i32, zextloadi16, LOAD16_U_I32>;
+def : LoadPatNoOffset<i64, sextloadi8, LOAD8_S_I64>;
+def : LoadPatNoOffset<i64, zextloadi8, LOAD8_U_I64>;
+def : LoadPatNoOffset<i64, sextloadi16, LOAD16_S_I64>;
+def : LoadPatNoOffset<i64, zextloadi16, LOAD16_U_I64>;
+def : LoadPatNoOffset<i64, sextloadi32, LOAD32_S_I64>;
+def : LoadPatNoOffset<i64, zextloadi32, LOAD32_U_I64>;
 
 // Select extending loads with a constant offset.
-def : Pat<(i32 (sextloadi8 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD8_S_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (zextloadi8 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD8_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (sextloadi16 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD16_S_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (zextloadi16 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD16_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i64 (sextloadi8 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD8_S_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (zextloadi8 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD8_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (sextloadi16 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD16_S_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (zextloadi16 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD16_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (sextloadi32 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD32_S_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (zextloadi32 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD32_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i32 (sextloadi8 (or_is_add I32:$addr, imm:$off))),
-          (LOAD8_S_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (zextloadi8 (or_is_add I32:$addr, imm:$off))),
-          (LOAD8_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (sextloadi16 (or_is_add I32:$addr, imm:$off))),
-          (LOAD16_S_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (zextloadi16 (or_is_add I32:$addr, imm:$off))),
-          (LOAD16_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i64 (sextloadi8 (or_is_add I32:$addr, imm:$off))),
-          (LOAD8_S_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (zextloadi8 (or_is_add I32:$addr, imm:$off))),
-          (LOAD8_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (sextloadi16 (or_is_add I32:$addr, imm:$off))),
-          (LOAD16_S_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (zextloadi16 (or_is_add I32:$addr, imm:$off))),
-          (LOAD16_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (sextloadi32 (or_is_add I32:$addr, imm:$off))),
-          (LOAD32_S_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (zextloadi32 (or_is_add I32:$addr, imm:$off))),
-          (LOAD32_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i32 (sextloadi8 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD8_S_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (zextloadi8 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD8_U_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (sextloadi16 (regPlusGA I32:$addr,
-                                       (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD16_S_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (zextloadi16 (regPlusGA I32:$addr,
-                                       (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD16_U_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (sextloadi8 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD8_S_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (zextloadi8 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD8_U_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (sextloadi16 (regPlusGA I32:$addr,
-                                       (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD16_S_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (zextloadi16 (regPlusGA I32:$addr,
-                                       (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD16_U_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (sextloadi32 (regPlusGA I32:$addr,
-                                       (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD32_S_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (zextloadi32 (regPlusGA I32:$addr,
-                                       (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD32_U_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (sextloadi8 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD8_S_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i32 (zextloadi8 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD8_U_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i32 (sextloadi16 (add I32:$addr,
-                                 (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD16_S_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i32 (zextloadi16 (add I32:$addr,
-                                 (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD16_U_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (sextloadi8 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD8_S_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (zextloadi8 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD8_U_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (sextloadi16 (add I32:$addr,
-                                 (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD16_S_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (zextloadi16 (add I32:$addr,
-                                 (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD16_U_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (sextloadi32 (add I32:$addr,
-                                 (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD32_S_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (zextloadi32 (add I32:$addr,
-                                 (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD32_U_I64 0, texternalsym:$off, $addr)>;
+def : LoadPatImmOff<i32, sextloadi8, regPlusImm, LOAD8_S_I32>;
+def : LoadPatImmOff<i32, zextloadi8, regPlusImm, LOAD8_U_I32>;
+def : LoadPatImmOff<i32, sextloadi16, regPlusImm, LOAD16_S_I32>;
+def : LoadPatImmOff<i32, zextloadi16, regPlusImm, LOAD16_U_I32>;
+def : LoadPatImmOff<i64, sextloadi8, regPlusImm, LOAD8_S_I64>;
+def : LoadPatImmOff<i64, zextloadi8, regPlusImm, LOAD8_U_I64>;
+def : LoadPatImmOff<i64, sextloadi16, regPlusImm, LOAD16_S_I64>;
+def : LoadPatImmOff<i64, zextloadi16, regPlusImm, LOAD16_U_I64>;
+def : LoadPatImmOff<i64, sextloadi32, regPlusImm, LOAD32_S_I64>;
+def : LoadPatImmOff<i64, zextloadi32, regPlusImm, LOAD32_U_I64>;
+
+def : LoadPatImmOff<i32, sextloadi8, or_is_add, LOAD8_S_I32>;
+def : LoadPatImmOff<i32, zextloadi8, or_is_add, LOAD8_U_I32>;
+def : LoadPatImmOff<i32, sextloadi16, or_is_add, LOAD16_S_I32>;
+def : LoadPatImmOff<i32, zextloadi16, or_is_add, LOAD16_U_I32>;
+def : LoadPatImmOff<i64, sextloadi8, or_is_add, LOAD8_S_I64>;
+def : LoadPatImmOff<i64, zextloadi8, or_is_add, LOAD8_U_I64>;
+def : LoadPatImmOff<i64, sextloadi16, or_is_add, LOAD16_S_I64>;
+def : LoadPatImmOff<i64, zextloadi16, or_is_add, LOAD16_U_I64>;
+def : LoadPatImmOff<i64, sextloadi32, or_is_add, LOAD32_S_I64>;
+def : LoadPatImmOff<i64, zextloadi32, or_is_add, LOAD32_U_I64>;
+
+def : LoadPatGlobalAddr<i32, sextloadi8, LOAD8_S_I32>;
+def : LoadPatGlobalAddr<i32, zextloadi8, LOAD8_U_I32>;
+def : LoadPatGlobalAddr<i32, sextloadi16, LOAD16_S_I32>;
+def : LoadPatGlobalAddr<i32, zextloadi8, LOAD16_U_I32>;
+
+def : LoadPatGlobalAddr<i64, sextloadi8, LOAD8_S_I64>;
+def : LoadPatGlobalAddr<i64, zextloadi8, LOAD8_U_I64>;
+def : LoadPatGlobalAddr<i64, sextloadi16, LOAD16_S_I64>;
+def : LoadPatGlobalAddr<i64, zextloadi16, LOAD16_U_I64>;
+def : LoadPatGlobalAddr<i64, sextloadi32, LOAD32_S_I64>;
+def : LoadPatGlobalAddr<i64, zextloadi32, LOAD32_U_I64>;
+
+def : LoadPatExternalSym<i32, sextloadi8, LOAD8_S_I32>;
+def : LoadPatExternalSym<i32, zextloadi8, LOAD8_U_I32>;
+def : LoadPatExternalSym<i32, sextloadi16, LOAD16_S_I32>;
+def : LoadPatExternalSym<i32, zextloadi16, LOAD16_U_I32>;
+def : LoadPatExternalSym<i64, sextloadi8, LOAD8_S_I64>;
+def : LoadPatExternalSym<i64, zextloadi8, LOAD8_U_I64>;
+def : LoadPatExternalSym<i64, sextloadi16, LOAD16_S_I64>;
+def : LoadPatExternalSym<i64, zextloadi16, LOAD16_U_I64>;
+def : LoadPatExternalSym<i64, sextloadi32, LOAD32_S_I64>;
+def : LoadPatExternalSym<i64, zextloadi32, LOAD32_U_I64>;
+
 
 // Select extending loads with just a constant offset.
-def : Pat<(i32 (sextloadi8 imm:$off)),
-          (LOAD8_S_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (zextloadi8 imm:$off)),
-          (LOAD8_U_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (sextloadi16 imm:$off)),
-          (LOAD16_S_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (zextloadi16 imm:$off)),
-          (LOAD16_U_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi8 imm:$off)),
-          (LOAD8_S_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi8 imm:$off)),
-          (LOAD8_U_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi16 imm:$off)),
-          (LOAD16_S_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi16 imm:$off)),
-          (LOAD16_U_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi32 imm:$off)),
-          (LOAD32_S_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi32 imm:$off)),
-          (LOAD32_U_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (sextloadi8 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD8_S_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (zextloadi8 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD8_U_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (sextloadi16 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD16_S_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (zextloadi16 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD16_U_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi8 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD8_S_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi8 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD8_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi16 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD16_S_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi16 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD16_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi32 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD32_S_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi32 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD32_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (sextloadi8 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD8_S_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i32 (zextloadi8 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD8_U_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i32 (sextloadi16 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD16_S_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i32 (zextloadi16 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD16_U_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi8 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD8_S_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi8 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD8_U_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi16 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD16_S_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi16 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD16_U_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (sextloadi32 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD32_S_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (zextloadi32 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD32_U_I64 0, texternalsym:$off, (CONST_I32 0))>;
+def : LoadPatOffsetOnly<i32, sextloadi8, LOAD8_S_I32>;
+def : LoadPatOffsetOnly<i32, zextloadi8, LOAD8_U_I32>;
+def : LoadPatOffsetOnly<i32, sextloadi16, LOAD16_S_I32>;
+def : LoadPatOffsetOnly<i32, zextloadi16, LOAD16_U_I32>;
+
+def : LoadPatOffsetOnly<i64, sextloadi8, LOAD8_S_I64>;
+def : LoadPatOffsetOnly<i64, zextloadi8, LOAD8_U_I64>;
+def : LoadPatOffsetOnly<i64, sextloadi16, LOAD16_S_I64>;
+def : LoadPatOffsetOnly<i64, zextloadi16, LOAD16_U_I64>;
+def : LoadPatOffsetOnly<i64, sextloadi32, LOAD32_S_I64>;
+def : LoadPatOffsetOnly<i64, zextloadi32, LOAD32_U_I64>;
+
+def : LoadPatGlobalAddrOffOnly<i32, sextloadi8, LOAD8_S_I32>;
+def : LoadPatGlobalAddrOffOnly<i32, zextloadi8, LOAD8_U_I32>;
+def : LoadPatGlobalAddrOffOnly<i32, sextloadi16, LOAD16_S_I32>;
+def : LoadPatGlobalAddrOffOnly<i32, zextloadi16, LOAD16_U_I32>;
+def : LoadPatGlobalAddrOffOnly<i64, sextloadi8, LOAD8_S_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, zextloadi8, LOAD8_U_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, sextloadi16, LOAD16_S_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, zextloadi16, LOAD16_U_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, sextloadi32, LOAD32_S_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, zextloadi32, LOAD32_U_I64>;
+
+def : LoadPatExternSymOffOnly<i32, sextloadi8, LOAD8_S_I32>;
+def : LoadPatExternSymOffOnly<i32, zextloadi8, LOAD8_U_I32>;
+def : LoadPatExternSymOffOnly<i32, sextloadi16, LOAD16_S_I32>;
+def : LoadPatExternSymOffOnly<i32, zextloadi16, LOAD16_U_I32>;
+def : LoadPatExternSymOffOnly<i64, sextloadi8, LOAD8_S_I64>;
+def : LoadPatExternSymOffOnly<i64, zextloadi8, LOAD8_U_I64>;
+def : LoadPatExternSymOffOnly<i64, sextloadi16, LOAD16_S_I64>;
+def : LoadPatExternSymOffOnly<i64, zextloadi16, LOAD16_U_I64>;
+def : LoadPatExternSymOffOnly<i64, sextloadi32, LOAD32_S_I64>;
+def : LoadPatExternSymOffOnly<i64, zextloadi32, LOAD32_U_I64>;
 
 // Resolve "don't care" extending loads to zero-extending loads. This is
 // somewhat arbitrary, but zero-extending is conceptually simpler.
 
 // Select "don't care" extending loads with no constant offset.
-def : Pat<(i32 (extloadi8 I32:$addr)),  (LOAD8_U_I32 0, 0, $addr)>;
-def : Pat<(i32 (extloadi16 I32:$addr)), (LOAD16_U_I32 0, 0, $addr)>;
-def : Pat<(i64 (extloadi8 I32:$addr)),  (LOAD8_U_I64 0, 0, $addr)>;
-def : Pat<(i64 (extloadi16 I32:$addr)), (LOAD16_U_I64 0, 0, $addr)>;
-def : Pat<(i64 (extloadi32 I32:$addr)), (LOAD32_U_I64 0, 0, $addr)>;
+def : LoadPatNoOffset<i32, extloadi8, LOAD8_U_I32>;
+def : LoadPatNoOffset<i32, extloadi16, LOAD16_U_I32>;
+def : LoadPatNoOffset<i64, extloadi8, LOAD8_U_I64>;
+def : LoadPatNoOffset<i64, extloadi16, LOAD16_U_I64>;
+def : LoadPatNoOffset<i64, extloadi32, LOAD32_U_I64>;
+
 
 // Select "don't care" extending loads with a constant offset.
-def : Pat<(i32 (extloadi8 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD8_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (extloadi16 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD16_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i64 (extloadi8 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD8_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (extloadi16 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD16_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (extloadi32 (regPlusImm I32:$addr, imm:$off))),
-          (LOAD32_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i32 (extloadi8 (or_is_add I32:$addr, imm:$off))),
-          (LOAD8_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i32 (extloadi16 (or_is_add I32:$addr, imm:$off))),
-          (LOAD16_U_I32 0, imm:$off, $addr)>;
-def : Pat<(i64 (extloadi8 (or_is_add I32:$addr, imm:$off))),
-          (LOAD8_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (extloadi16 (or_is_add I32:$addr, imm:$off))),
-          (LOAD16_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i64 (extloadi32 (or_is_add I32:$addr, imm:$off))),
-          (LOAD32_U_I64 0, imm:$off, $addr)>;
-def : Pat<(i32 (extloadi8 (regPlusGA I32:$addr,
-                                     (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD8_U_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (extloadi16 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD16_U_I32 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (extloadi8 (regPlusGA I32:$addr,
-                                     (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD8_U_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (extloadi16 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD16_U_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i64 (extloadi32 (regPlusGA I32:$addr,
-                                      (WebAssemblywrapper tglobaladdr:$off)))),
-          (LOAD32_U_I64 0, tglobaladdr:$off, $addr)>;
-def : Pat<(i32 (extloadi8 (add I32:$addr,
-                               (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD8_U_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i32 (extloadi16 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD16_U_I32 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (extloadi8 (add I32:$addr,
-                               (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD8_U_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (extloadi16 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD16_U_I64 0, texternalsym:$off, $addr)>;
-def : Pat<(i64 (extloadi32 (add I32:$addr,
-                                (WebAssemblywrapper texternalsym:$off)))),
-          (LOAD32_U_I64 0, texternalsym:$off, $addr)>;
+def : LoadPatImmOff<i32, extloadi8, regPlusImm, LOAD8_U_I32>;
+def : LoadPatImmOff<i32, extloadi16, regPlusImm, LOAD16_U_I32>;
+def : LoadPatImmOff<i64, extloadi8, regPlusImm, LOAD8_U_I64>;
+def : LoadPatImmOff<i64, extloadi16, regPlusImm, LOAD16_U_I64>;
+def : LoadPatImmOff<i64, extloadi32, regPlusImm, LOAD32_U_I64>;
+def : LoadPatImmOff<i32, extloadi8, or_is_add, LOAD8_U_I32>;
+def : LoadPatImmOff<i32, extloadi16, or_is_add, LOAD16_U_I32>;
+def : LoadPatImmOff<i64, extloadi8, or_is_add, LOAD8_U_I64>;
+def : LoadPatImmOff<i64, extloadi16, or_is_add, LOAD16_U_I64>;
+def : LoadPatImmOff<i64, extloadi32, or_is_add, LOAD32_U_I64>;
+def : LoadPatGlobalAddr<i32, extloadi8, LOAD8_U_I32>;
+def : LoadPatGlobalAddr<i32, extloadi16, LOAD16_U_I32>;
+def : LoadPatGlobalAddr<i64, extloadi8, LOAD8_U_I64>;
+def : LoadPatGlobalAddr<i64, extloadi16, LOAD16_U_I64>;
+def : LoadPatGlobalAddr<i64, extloadi32, LOAD32_U_I64>;
+def : LoadPatExternalSym<i32, extloadi8, LOAD8_U_I32>;
+def : LoadPatExternalSym<i32, extloadi16, LOAD16_U_I32>;
+def : LoadPatExternalSym<i64, extloadi8, LOAD8_U_I64>;
+def : LoadPatExternalSym<i64, extloadi16, LOAD16_U_I64>;
+def : LoadPatExternalSym<i64, extloadi32, LOAD32_U_I64>;
+
 
 // Select "don't care" extending loads with just a constant offset.
-def : Pat<(i32 (extloadi8 imm:$off)),
-          (LOAD8_U_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (extloadi16 imm:$off)),
-          (LOAD16_U_I32 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi8 imm:$off)),
-          (LOAD8_U_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi16 imm:$off)),
-          (LOAD16_U_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi32 imm:$off)),
-          (LOAD32_U_I64 0, imm:$off, (CONST_I32 0))>;
-def : Pat<(i32 (extloadi8 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD8_U_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (extloadi16 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD16_U_I32 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi8 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD8_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi16 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD16_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi32 (WebAssemblywrapper tglobaladdr:$off))),
-          (LOAD32_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
-def : Pat<(i32 (extloadi8 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD8_U_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i32 (extloadi16 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD16_U_I32 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi8 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD8_U_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi16 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD16_U_I64 0, texternalsym:$off, (CONST_I32 0))>;
-def : Pat<(i64 (extloadi32 (WebAssemblywrapper texternalsym:$off))),
-          (LOAD32_U_I64 0, tglobaladdr:$off, (CONST_I32 0))>;
+def : LoadPatOffsetOnly<i32, extloadi8, LOAD8_U_I32>;
+def : LoadPatOffsetOnly<i32, extloadi16, LOAD16_U_I32>;
+def : LoadPatOffsetOnly<i64, extloadi8, LOAD8_U_I64>;
+def : LoadPatOffsetOnly<i64, extloadi16, LOAD16_U_I64>;
+def : LoadPatOffsetOnly<i64, extloadi32, LOAD32_U_I64>;
+def : LoadPatGlobalAddrOffOnly<i32, extloadi8, LOAD8_U_I32>;
+def : LoadPatGlobalAddrOffOnly<i32, extloadi16, LOAD16_U_I32>;
+def : LoadPatGlobalAddrOffOnly<i64, extloadi8, LOAD8_U_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, extloadi16, LOAD16_U_I64>;
+def : LoadPatGlobalAddrOffOnly<i64, extloadi32, LOAD32_U_I64>;
+def : LoadPatExternSymOffOnly<i32, extloadi8, LOAD8_U_I32>;
+def : LoadPatExternSymOffOnly<i32, extloadi16, LOAD16_U_I32>;
+def : LoadPatExternSymOffOnly<i64, extloadi8, LOAD8_U_I64>;
+def : LoadPatExternSymOffOnly<i64, extloadi16, LOAD16_U_I64>;
+def : LoadPatExternSymOffOnly<i64, extloadi32, LOAD32_U_I64>;
+
 
 let Defs = [ARGUMENTS] in {
 
 // Basic store.
 // Note: WebAssembly inverts SelectionDAG's usual operand order.
 def STORE_I32  : I<(outs), (ins P2Align:$p2align, offset32_op:$off, I32:$addr,
                             I32:$val), [],
                    "i32.store\t${off}(${addr})${p2align}, $val", 0x36>;

llvm/trunk/test/CodeGen/WebAssembly/atomics.ll

 ; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt 
-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -mattr=+atomics | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+atomics | FileCheck %s
 
 ; Test that atomic loads are assembled properly.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; CHECK-LABEL: load_i32_atomic:
-; CHECK-NEXT: .param i32{{$}}
-; CHECK-NEXT: .result i32{{$}}
-; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
-; CHECK-NEXT: i32.atomic.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}}
+; CHECK: i32.atomic.load $push[[NUM:[0-9]+]]=, 0($0){{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 
 define i32 @load_i32_atomic(i32 *%p) {
   %v = load atomic i32, i32* %p seq_cst, align 4
   ret i32 %v
 }