[WebAssembly] Set alignment to 1 for SIMD memory intrinsics

[tlively]

Summary

The WebAssembly SIMD intrinsics in wasm_simd128.h generally try not to require
any particular alignment for memory operations to be maximally flexible. For
builtin memory access functions and their corresponding LLVM IR intrinsics,
there's no way to set the expected alignment, so the best we can do is set the
alignment to 1 in the backend. This change means that the alignment hints in the
emitted code will no longer be incorrect when users use the intrinsics to access
unaligned data.

[aheejin]

Sorry I'm not sure if I understand. The "expected alignment" for all those memory instructions is 1, regardless of the size of the element of the vectors? Can you elaborate on why the previous code is incorrect?

[tlively]

In D101850#2737379, @aheejin wrote:

Sorry I'm not sure if I understand. The "expected alignment" for all those memory instructions is 1, regardless of the size of the element of the vectors? Can you elaborate on why the previous code is incorrect?

Users of the SIMD intrinsic header functions (and therefore the clang builtins (and therefore the LLVM intrinsics)) for these instructions should be able to pass pointers to arbitrary unaligned data. In the backend, we won't know what the alignment of the data is, so we need to conservatively say that it is 1. Previously, if users used those intrinsics with unaligned data, the alignment hint emitted into the binary would be wrong because it would be too big.

[aheejin]

Thanks for the explanation!

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

case Intrinsic::wasm_memory_atomic_wait64:
     Info.flags = MachineMemOperand::MOVolatile | MachineMemOperand::MOLoad;
     return true;
   case Intrinsic::wasm_load32_zero:
   case Intrinsic::wasm_load64_zero:
     Info.opc = ISD::INTRINSIC_W_CHAIN;
     Info.memVT = Intrinsic == Intrinsic::wasm_load32_zero ? MVT::i32 : MVT::i64;
     Info.ptrVal = I.getArgOperand(0);
     Info.offset = 0;
-    Info.align = Info.memVT == MVT::i32 ? Align(4) : Align(8);
+    Info.align = Align(1);
     Info.flags = MachineMemOperand::MOLoad;
     return true;
   case Intrinsic::wasm_load8_lane:
   case Intrinsic::wasm_load16_lane:
   case Intrinsic::wasm_load32_lane:
   case Intrinsic::wasm_load64_lane:
   case Intrinsic::wasm_store8_lane:
   case Intrinsic::wasm_store16_lane:
   case Intrinsic::wasm_store32_lane:
   case Intrinsic::wasm_store64_lane: {
     MVT MemVT;
-    Align MemAlign;
     switch (Intrinsic) {
     case Intrinsic::wasm_load8_lane:
     case Intrinsic::wasm_store8_lane:
       MemVT = MVT::i8;
-      MemAlign = Align(1);
       break;
     case Intrinsic::wasm_load16_lane:
     case Intrinsic::wasm_store16_lane:
       MemVT = MVT::i16;
-      MemAlign = Align(2);
       break;
     case Intrinsic::wasm_load32_lane:
     case Intrinsic::wasm_store32_lane:
       MemVT = MVT::i32;
-      MemAlign = Align(4);
       break;
     case Intrinsic::wasm_load64_lane:
     case Intrinsic::wasm_store64_lane:
       MemVT = MVT::i64;
-      MemAlign = Align(8);
       break;
     default:
       llvm_unreachable("unexpected intrinsic");
     }
     if (Intrinsic == Intrinsic::wasm_load8_lane ||
         Intrinsic == Intrinsic::wasm_load16_lane ||
         Intrinsic == Intrinsic::wasm_load32_lane ||
         Intrinsic == Intrinsic::wasm_load64_lane) {
       Info.opc = ISD::INTRINSIC_W_CHAIN;
       Info.flags = MachineMemOperand::MOLoad;
     } else {
       Info.opc = ISD::INTRINSIC_VOID;
       Info.flags = MachineMemOperand::MOStore;
     }
     Info.ptrVal = I.getArgOperand(0);
     Info.memVT = MemVT;
     Info.offset = 0;
-    Info.align = MemAlign;
+    Info.align = Align(1);
     return true;
   }
   default:
     return false;
   }
 }
 
 //===----------------------------------------------------------------------===//

llvm/test/CodeGen/WebAssembly/simd-load-lane-offset.ll

 ;===----------------------------------------------------------------------------
 
 define <8 x i16> @load_lane_i16_no_offset(i16* %p, <8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_no_offset:
 ; CHECK:         .functype load_lane_i16_no_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %p, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define <8 x i16> @load_lane_i16_with_folded_offset(i16* %p, <8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_with_folded_offset:
 ; CHECK:         .functype load_lane_i16_with_folded_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i16* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i16*
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define <8 x i16> @load_lane_i16_with_folded_gep_offset(i16* %p, <8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_with_folded_gep_offset:
 ; CHECK:         .functype load_lane_i16_with_folded_gep_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 12
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i16, i16* %p, i32 6
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define <8 x i16> @load_lane_i16_with_unfolded_gep_negative_offset(i16* %p, <8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype load_lane_i16_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const -12
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i16, i16* %p, i32 -6
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define <8 x i16> @load_lane_i16_with_unfolded_offset(i16* %p, <8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_with_unfolded_offset:
 ; CHECK:         .functype load_lane_i16_with_unfolded_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i16* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i16*
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define <8 x i16> @load_lane_i16_with_unfolded_gep_offset(i16* %p, <8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_with_unfolded_gep_offset:
 ; CHECK:         .functype load_lane_i16_with_unfolded_gep_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 12
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i16, i16* %p, i32 6
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define <8 x i16> @load_lane_i16_from_numeric_address(<8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_from_numeric_address:
 ; CHECK:         .functype load_lane_i16_from_numeric_address (v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 42
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i16*
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 @gv_i16 = global i16 0
 define <8 x i16> @load_lane_i16_from_global_address(<8 x i16> %v) {
 ; CHECK-LABEL: load_lane_i16_from_global_address:
 ; CHECK:         .functype load_lane_i16_from_global_address (v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const gv_i16
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load16_lane 0, 0
+; CHECK-NEXT:    v128.load16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <8 x i16> @llvm.wasm.load16.lane(i16* @gv_i16, <8 x i16> %v, i32 0)
   ret <8 x i16> %t
 }
 
 define void @store_lane_i16_no_offset(<8 x i16> %v, i16* %p) {
 ; CHECK-LABEL: store_lane_i16_no_offset:
 ; CHECK:         .functype store_lane_i16_no_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   tail call void @llvm.wasm.store16.lane(i16* %p, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_with_folded_offset(<8 x i16> %v, i16* %p) {
 ; CHECK-LABEL: store_lane_i16_with_folded_offset:
 ; CHECK:         .functype store_lane_i16_with_folded_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i16* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i16*
   tail call void @llvm.wasm.store16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_with_folded_gep_offset(<8 x i16> %v, i16* %p) {
 ; CHECK-LABEL: store_lane_i16_with_folded_gep_offset:
 ; CHECK:         .functype store_lane_i16_with_folded_gep_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 12
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i16, i16* %p, i32 6
   tail call void @llvm.wasm.store16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_with_unfolded_gep_negative_offset(<8 x i16> %v, i16* %p) {
 ; CHECK-LABEL: store_lane_i16_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype store_lane_i16_with_unfolded_gep_negative_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const -12
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i16, i16* %p, i32 -6
   tail call void @llvm.wasm.store16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_with_unfolded_offset(<8 x i16> %v, i16* %p) {
 ; CHECK-LABEL: store_lane_i16_with_unfolded_offset:
 ; CHECK:         .functype store_lane_i16_with_unfolded_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i16* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i16*
   tail call void @llvm.wasm.store16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_with_unfolded_gep_offset(<8 x i16> %v, i16* %p) {
 ; CHECK-LABEL: store_lane_i16_with_unfolded_gep_offset:
 ; CHECK:         .functype store_lane_i16_with_unfolded_gep_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 12
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i16, i16* %p, i32 6
   tail call void @llvm.wasm.store16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_to_numeric_address(<8 x i16> %v) {
 ; CHECK-LABEL: store_lane_i16_to_numeric_address:
 ; CHECK:         .functype store_lane_i16_to_numeric_address (v128) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 42
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i16*
   tail call void @llvm.wasm.store16.lane(i16* %s, <8 x i16> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i16_from_global_address(<8 x i16> %v) {
 ; CHECK-LABEL: store_lane_i16_from_global_address:
 ; CHECK:         .functype store_lane_i16_from_global_address (v128) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const gv_i16
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store16_lane 0, 0
+; CHECK-NEXT:    v128.store16_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   tail call void @llvm.wasm.store16.lane(i16* @gv_i16, <8 x i16> %v, i32 0)
   ret void
 }
 
 ;===----------------------------------------------------------------------------
 ; v128.load32_lane / v128.store32_lane
 ;===----------------------------------------------------------------------------
 
 define <4 x i32> @load_lane_i32_no_offset(i32* %p, <4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_no_offset:
 ; CHECK:         .functype load_lane_i32_no_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %p, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_lane_i32_with_folded_offset(i32* %p, <4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_with_folded_offset:
 ; CHECK:         .functype load_lane_i32_with_folded_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i32* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i32*
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_lane_i32_with_folded_gep_offset(i32* %p, <4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_with_folded_gep_offset:
 ; CHECK:         .functype load_lane_i32_with_folded_gep_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i32, i32* %p, i32 6
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_lane_i32_with_unfolded_gep_negative_offset(i32* %p, <4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype load_lane_i32_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const -24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i32, i32* %p, i32 -6
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_lane_i32_with_unfolded_offset(i32* %p, <4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_with_unfolded_offset:
 ; CHECK:         .functype load_lane_i32_with_unfolded_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i32* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i32*
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_lane_i32_with_unfolded_gep_offset(i32* %p, <4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_with_unfolded_gep_offset:
 ; CHECK:         .functype load_lane_i32_with_unfolded_gep_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i32, i32* %p, i32 6
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_lane_i32_from_numeric_address(<4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_from_numeric_address:
 ; CHECK:         .functype load_lane_i32_from_numeric_address (v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 42
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i32*
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 @gv_i32 = global i32 0
 define <4 x i32> @load_lane_i32_from_global_address(<4 x i32> %v) {
 ; CHECK-LABEL: load_lane_i32_from_global_address:
 ; CHECK:         .functype load_lane_i32_from_global_address (v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const gv_i32
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load32_lane 0, 0
+; CHECK-NEXT:    v128.load32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <4 x i32> @llvm.wasm.load32.lane(i32* @gv_i32, <4 x i32> %v, i32 0)
   ret <4 x i32> %t
 }
 
 define void @store_lane_i32_no_offset(<4 x i32> %v, i32* %p) {
 ; CHECK-LABEL: store_lane_i32_no_offset:
 ; CHECK:         .functype store_lane_i32_no_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   tail call void @llvm.wasm.store32.lane(i32* %p, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_with_folded_offset(<4 x i32> %v, i32* %p) {
 ; CHECK-LABEL: store_lane_i32_with_folded_offset:
 ; CHECK:         .functype store_lane_i32_with_folded_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i32* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i32*
   tail call void @llvm.wasm.store32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_with_folded_gep_offset(<4 x i32> %v, i32* %p) {
 ; CHECK-LABEL: store_lane_i32_with_folded_gep_offset:
 ; CHECK:         .functype store_lane_i32_with_folded_gep_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i32, i32* %p, i32 6
   tail call void @llvm.wasm.store32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_with_unfolded_gep_negative_offset(<4 x i32> %v, i32* %p) {
 ; CHECK-LABEL: store_lane_i32_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype store_lane_i32_with_unfolded_gep_negative_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const -24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i32, i32* %p, i32 -6
   tail call void @llvm.wasm.store32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_with_unfolded_offset(<4 x i32> %v, i32* %p) {
 ; CHECK-LABEL: store_lane_i32_with_unfolded_offset:
 ; CHECK:         .functype store_lane_i32_with_unfolded_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i32* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i32*
   tail call void @llvm.wasm.store32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_with_unfolded_gep_offset(<4 x i32> %v, i32* %p) {
 ; CHECK-LABEL: store_lane_i32_with_unfolded_gep_offset:
 ; CHECK:         .functype store_lane_i32_with_unfolded_gep_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i32, i32* %p, i32 6
   tail call void @llvm.wasm.store32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_to_numeric_address(<4 x i32> %v) {
 ; CHECK-LABEL: store_lane_i32_to_numeric_address:
 ; CHECK:         .functype store_lane_i32_to_numeric_address (v128) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 42
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i32*
   tail call void @llvm.wasm.store32.lane(i32* %s, <4 x i32> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i32_from_global_address(<4 x i32> %v) {
 ; CHECK-LABEL: store_lane_i32_from_global_address:
 ; CHECK:         .functype store_lane_i32_from_global_address (v128) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const gv_i32
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store32_lane 0, 0
+; CHECK-NEXT:    v128.store32_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   tail call void @llvm.wasm.store32.lane(i32* @gv_i32, <4 x i32> %v, i32 0)
   ret void
 }
 
 ;===----------------------------------------------------------------------------
 ; v128.load64_lane / v128.store64_lane
 ;===----------------------------------------------------------------------------
 
 define <2 x i64> @load_lane_i64_no_offset(i64* %p, <2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_no_offset:
 ; CHECK:         .functype load_lane_i64_no_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %p, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_lane_i64_with_folded_offset(i64* %p, <2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_with_folded_offset:
 ; CHECK:         .functype load_lane_i64_with_folded_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i64* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i64*
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_lane_i64_with_folded_gep_offset(i64* %p, <2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_with_folded_gep_offset:
 ; CHECK:         .functype load_lane_i64_with_folded_gep_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 48
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i64, i64* %p, i32 6
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_lane_i64_with_unfolded_gep_negative_offset(i64* %p, <2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype load_lane_i64_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const -48
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i64, i64* %p, i32 -6
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_lane_i64_with_unfolded_offset(i64* %p, <2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_with_unfolded_offset:
 ; CHECK:         .functype load_lane_i64_with_unfolded_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i64* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i64*
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_lane_i64_with_unfolded_gep_offset(i64* %p, <2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_with_unfolded_gep_offset:
 ; CHECK:         .functype load_lane_i64_with_unfolded_gep_offset (i32, v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 48
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 1
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i64, i64* %p, i32 6
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_lane_i64_from_numeric_address(<2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_from_numeric_address:
 ; CHECK:         .functype load_lane_i64_from_numeric_address (v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 42
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i64*
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 @gv_i64 = global i64 0
 define <2 x i64> @load_lane_i64_from_global_address(<2 x i64> %v) {
 ; CHECK-LABEL: load_lane_i64_from_global_address:
 ; CHECK:         .functype load_lane_i64_from_global_address (v128) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const gv_i64
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load64_lane 0, 0
+; CHECK-NEXT:    v128.load64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <2 x i64> @llvm.wasm.load64.lane(i64* @gv_i64, <2 x i64> %v, i32 0)
   ret <2 x i64> %t
 }
 
 define void @store_lane_i64_no_offset(<2 x i64> %v, i64* %p) {
 ; CHECK-LABEL: store_lane_i64_no_offset:
 ; CHECK:         .functype store_lane_i64_no_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   tail call void @llvm.wasm.store64.lane(i64* %p, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_with_folded_offset(<2 x i64> %v, i64* %p) {
 ; CHECK-LABEL: store_lane_i64_with_folded_offset:
 ; CHECK:         .functype store_lane_i64_with_folded_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i64* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i64*
   tail call void @llvm.wasm.store64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_with_folded_gep_offset(<2 x i64> %v, i64* %p) {
 ; CHECK-LABEL: store_lane_i64_with_folded_gep_offset:
 ; CHECK:         .functype store_lane_i64_with_folded_gep_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 48
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i64, i64* %p, i32 6
   tail call void @llvm.wasm.store64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_with_unfolded_gep_negative_offset(<2 x i64> %v, i64* %p) {
 ; CHECK-LABEL: store_lane_i64_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype store_lane_i64_with_unfolded_gep_negative_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const -48
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i64, i64* %p, i32 -6
   tail call void @llvm.wasm.store64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_with_unfolded_offset(<2 x i64> %v, i64* %p) {
 ; CHECK-LABEL: store_lane_i64_with_unfolded_offset:
 ; CHECK:         .functype store_lane_i64_with_unfolded_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i64* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i64*
   tail call void @llvm.wasm.store64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_with_unfolded_gep_offset(<2 x i64> %v, i64* %p) {
 ; CHECK-LABEL: store_lane_i64_with_unfolded_gep_offset:
 ; CHECK:         .functype store_lane_i64_with_unfolded_gep_offset (v128, i32) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 1
 ; CHECK-NEXT:    i32.const 48
 ; CHECK-NEXT:    i32.add
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i64, i64* %p, i32 6
   tail call void @llvm.wasm.store64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_to_numeric_address(<2 x i64> %v) {
 ; CHECK-LABEL: store_lane_i64_to_numeric_address:
 ; CHECK:         .functype store_lane_i64_to_numeric_address (v128) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 42
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i64*
   tail call void @llvm.wasm.store64.lane(i64* %s, <2 x i64> %v, i32 0)
   ret void
 }
 
 define void @store_lane_i64_from_global_address(<2 x i64> %v) {
 ; CHECK-LABEL: store_lane_i64_from_global_address:
 ; CHECK:         .functype store_lane_i64_from_global_address (v128) -> ()
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const gv_i64
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.store64_lane 0, 0
+; CHECK-NEXT:    v128.store64_lane 0:p2align=0, 0
 ; CHECK-NEXT:    # fallthrough-return
   tail call void @llvm.wasm.store64.lane(i64* @gv_i64, <2 x i64> %v, i32 0)
   ret void
 }

llvm/test/CodeGen/WebAssembly/simd-load-zero-offset.ll

 ; v128.load32_zero
 ;===----------------------------------------------------------------------------
 
 define <4 x i32> @load_zero_i32_no_offset(i32* %p) {
 ; CHECK-LABEL: load_zero_i32_no_offset:
 ; CHECK:         .functype load_zero_i32_no_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load32_zero 0
+; CHECK-NEXT:    v128.load32_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %v = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %p)
   ret <4 x i32> %v
 }
 
 define <4 x i32> @load_zero_i32_with_folded_offset(i32* %p) {
 ; CHECK-LABEL: load_zero_i32_with_folded_offset:
 ; CHECK:         .functype load_zero_i32_with_folded_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load32_zero 24
+; CHECK-NEXT:    v128.load32_zero 24:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i32* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i32*
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %s)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_zero_i32_with_folded_gep_offset(i32* %p) {
 ; CHECK-LABEL: load_zero_i32_with_folded_gep_offset:
 ; CHECK:         .functype load_zero_i32_with_folded_gep_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load32_zero 24
+; CHECK-NEXT:    v128.load32_zero 24:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i32, i32* %p, i32 6
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %s)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_zero_i32_with_unfolded_gep_negative_offset(i32* %p) {
 ; CHECK-LABEL: load_zero_i32_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype load_zero_i32_with_unfolded_gep_negative_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const -24
 ; CHECK-NEXT:    i32.add
-; CHECK-NEXT:    v128.load32_zero 0
+; CHECK-NEXT:    v128.load32_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i32, i32* %p, i32 -6
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %s)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_zero_i32_with_unfolded_offset(i32* %p) {
 ; CHECK-LABEL: load_zero_i32_with_unfolded_offset:
 ; CHECK:         .functype load_zero_i32_with_unfolded_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
-; CHECK-NEXT:    v128.load32_zero 0
+; CHECK-NEXT:    v128.load32_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i32* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i32*
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %s)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_zero_i32_with_unfolded_gep_offset(i32* %p) {
 ; CHECK-LABEL: load_zero_i32_with_unfolded_gep_offset:
 ; CHECK:         .functype load_zero_i32_with_unfolded_gep_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
-; CHECK-NEXT:    v128.load32_zero 0
+; CHECK-NEXT:    v128.load32_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i32, i32* %p, i32 6
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %s)
   ret <4 x i32> %t
 }
 
 define <4 x i32> @load_zero_i32_from_numeric_address() {
 ; CHECK-LABEL: load_zero_i32_from_numeric_address:
 ; CHECK:         .functype load_zero_i32_from_numeric_address () -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    v128.load32_zero 42
+; CHECK-NEXT:    v128.load32_zero 42:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i32*
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* %s)
   ret <4 x i32> %t
 }
 
 @gv_i32 = global i32 0
 define <4 x i32> @load_zero_i32_from_global_address() {
 ; CHECK-LABEL: load_zero_i32_from_global_address:
 ; CHECK:         .functype load_zero_i32_from_global_address () -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    v128.load32_zero gv_i32
+; CHECK-NEXT:    v128.load32_zero gv_i32:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <4 x i32> @llvm.wasm.load32.zero(i32* @gv_i32)
   ret <4 x i32> %t
 }
 
 ;===----------------------------------------------------------------------------
 ; v128.load64_zero
 ;===----------------------------------------------------------------------------
 
 define <2 x i64> @load_zero_i64_no_offset(i64* %p) {
 ; CHECK-LABEL: load_zero_i64_no_offset:
 ; CHECK:         .functype load_zero_i64_no_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load64_zero 0
+; CHECK-NEXT:    v128.load64_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %v = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %p)
   ret <2 x i64> %v
 }
 
 define <2 x i64> @load_zero_i64_with_folded_offset(i64* %p) {
 ; CHECK-LABEL: load_zero_i64_with_folded_offset:
 ; CHECK:         .functype load_zero_i64_with_folded_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load64_zero 24
+; CHECK-NEXT:    v128.load64_zero 24:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i64* %p to i32
   %r = add nuw i32 %q, 24
   %s = inttoptr i32 %r to i64*
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %s)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_zero_i64_with_folded_gep_offset(i64* %p) {
 ; CHECK-LABEL: load_zero_i64_with_folded_gep_offset:
 ; CHECK:         .functype load_zero_i64_with_folded_gep_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
-; CHECK-NEXT:    v128.load64_zero 48
+; CHECK-NEXT:    v128.load64_zero 48:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i64, i64* %p, i64 6
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %s)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_zero_i64_with_unfolded_gep_negative_offset(i64* %p) {
 ; CHECK-LABEL: load_zero_i64_with_unfolded_gep_negative_offset:
 ; CHECK:         .functype load_zero_i64_with_unfolded_gep_negative_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const -48
 ; CHECK-NEXT:    i32.add
-; CHECK-NEXT:    v128.load64_zero 0
+; CHECK-NEXT:    v128.load64_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr inbounds i64, i64* %p, i64 -6
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %s)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_zero_i64_with_unfolded_offset(i64* %p) {
 ; CHECK-LABEL: load_zero_i64_with_unfolded_offset:
 ; CHECK:         .functype load_zero_i64_with_unfolded_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 24
 ; CHECK-NEXT:    i32.add
-; CHECK-NEXT:    v128.load64_zero 0
+; CHECK-NEXT:    v128.load64_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %q = ptrtoint i64* %p to i32
   %r = add nsw i32 %q, 24
   %s = inttoptr i32 %r to i64*
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %s)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_zero_i64_with_unfolded_gep_offset(i64* %p) {
 ; CHECK-LABEL: load_zero_i64_with_unfolded_gep_offset:
 ; CHECK:         .functype load_zero_i64_with_unfolded_gep_offset (i32) -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    local.get 0
 ; CHECK-NEXT:    i32.const 48
 ; CHECK-NEXT:    i32.add
-; CHECK-NEXT:    v128.load64_zero 0
+; CHECK-NEXT:    v128.load64_zero 0:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = getelementptr i64, i64* %p, i64 6
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %s)
   ret <2 x i64> %t
 }
 
 define <2 x i64> @load_zero_i64_from_numeric_address() {
 ; CHECK-LABEL: load_zero_i64_from_numeric_address:
 ; CHECK:         .functype load_zero_i64_from_numeric_address () -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    v128.load64_zero 42
+; CHECK-NEXT:    v128.load64_zero 42:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %s = inttoptr i32 42 to i64*
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* %s)
   ret <2 x i64> %t
 }
 
 @gv_i64 = global i64 0
 define <2 x i64> @load_zero_i64_from_global_address() {
 ; CHECK-LABEL: load_zero_i64_from_global_address:
 ; CHECK:         .functype load_zero_i64_from_global_address () -> (v128)
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    i32.const 0
-; CHECK-NEXT:    v128.load64_zero gv_i64
+; CHECK-NEXT:    v128.load64_zero gv_i64:p2align=0
 ; CHECK-NEXT:    # fallthrough-return
   %t = tail call <2 x i64> @llvm.wasm.load64.zero(i64* @gv_i64)
   ret <2 x i64> %t
 }