diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
index 4a68587fc224..3f33b0ec5e95 100644
--- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h
+++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h
@@ -856,10 +856,13 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
       addr = addr.withPointer(
           createPtrBitcast(addr.getPointer(), addr.getElementType()));
 
+    mlir::IntegerAttr align;
+    uint64_t alignment = addr.getAlignment().getQuantity();
+    if (alignment)
+      align = getI64IntegerAttr(alignment);
     return create<cir::LoadOp>(
         loc, addr.getElementType(), addr.getPointer(), /*isDeref=*/false,
-        /*is_volatile=*/isVolatile, /*is_nontemporal=*/isNontemporal,
-        /*alignment=*/mlir::IntegerAttr{},
+        /*is_volatile=*/isVolatile, /*is_nontemporal=*/isNontemporal, align,
         /*mem_order=*/cir::MemOrderAttr{}, /*tbaa=*/cir::TBAAAttr{});
   }
 
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
index 86da04457266..a9e448e2024d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -2946,16 +2946,9 @@ mlir::Value CIRGenFunction::emitLoadOfScalar(Address addr, bool isVolatile,
     llvm_unreachable("NYI");
   }
 
-  // TODO(cir): modernize this with addr.withElementType(convertTypeForLoadStore
-  auto Ptr = addr.getPointer();
-  if (mlir::isa<cir::VoidType>(eltTy)) {
-    eltTy = cir::IntType::get(&getMLIRContext(), 8, true);
-    auto ElemPtrTy = cir::PointerType::get(eltTy);
-    Ptr = builder.create<cir::CastOp>(loc, ElemPtrTy, cir::CastKind::bitcast,
-                                      Ptr);
-  }
-  auto loadOp =
-      builder.CIRBaseBuilderTy::createLoad(loc, Ptr, isVolatile, isNontemporal);
+  if (mlir::isa<cir::VoidType>(eltTy))
+    addr = addr.withElementType(builder, builder.getUIntNTy(8));
+  auto loadOp = builder.createLoad(loc, addr, isVolatile, isNontemporal);
 
   CGM.decorateOperationWithTBAA(loadOp, tbaaInfo);
 
diff --git a/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c b/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c
index c85ab06b7d2a..6153912a42b7 100644
--- a/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c
+++ b/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c
@@ -30,7 +30,7 @@ typedef struct {
 // CHECK: cir.func {{.*@ret_lt_64}}() -> !u16i
 // CHECK:   %[[#V0:]] = cir.alloca !rec_LT_64, !cir.ptr<!rec_LT_64>, ["__retval"]
 // CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_LT_64>), !cir.ptr<!u16i>
-// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!u16i>, !u16i
+// CHECK:   %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!u16i>, !u16i
 // CHECK:   cir.return %[[#V2]] : !u16i
 LT_64 ret_lt_64() {
   LT_64 x;
@@ -40,7 +40,7 @@ LT_64 ret_lt_64() {
 // CHECK: cir.func {{.*@ret_eq_64}}() -> !u64i
 // CHECK:   %[[#V0:]] = cir.alloca !rec_EQ_64, !cir.ptr<!rec_EQ_64>, ["__retval"]
 // CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_EQ_64>), !cir.ptr<!u64i>
-// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!u64i>, !u64i
+// CHECK:   %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!u64i>, !u64i
 // CHECK:   cir.return %[[#V2]] : !u64i
 EQ_64 ret_eq_64() {
   EQ_64 x;
@@ -50,7 +50,7 @@ EQ_64 ret_eq_64() {
 // CHECK: cir.func {{.*@ret_lt_128}}() -> !cir.array<!u64i x 2>
 // CHECK:   %[[#V0:]] = cir.alloca !rec_LT_128, !cir.ptr<!rec_LT_128>, ["__retval"]
 // CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_LT_128>), !cir.ptr<!cir.array<!u64i x 2>>
-// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
+// CHECK:   %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
 // CHECK:   cir.return %[[#V2]] : !cir.array<!u64i x 2>
 LT_128 ret_lt_128() {
   LT_128 x;
@@ -60,7 +60,7 @@ LT_128 ret_lt_128() {
 // CHECK: cir.func {{.*@ret_eq_128}}() -> !cir.array<!u64i x 2>
 // CHECK:   %[[#V0:]] = cir.alloca !rec_EQ_128, !cir.ptr<!rec_EQ_128>, ["__retval"]
 // CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_EQ_128>), !cir.ptr<!cir.array<!u64i x 2>>
-// CHECK:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
+// CHECK:   %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
 // CHECK:   cir.return %[[#V2]] : !cir.array<!u64i x 2>
 EQ_128 ret_eq_128() {
   EQ_128 x;
@@ -87,7 +87,7 @@ typedef struct {
 // CHECK:   %[[#V3:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>), !cir.ptr<!void>
 // CHECK:   %[[#V4:]] = cir.const #cir.int<12> : !u64i
 // CHECK:   cir.libc.memcpy %[[#V4]] bytes from %[[#V2]] to %[[#V3]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
-// CHECK:   %[[#V5:]] = cir.load %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
+// CHECK:   %[[#V5:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
 // CHECK:   cir.return %[[#V5]] : !cir.array<!u64i x 2>
 
 // LLVM: [2 x i64] @retS() 
@@ -145,7 +145,7 @@ void pass_eq_128(EQ_128 s) {}
 // CHECK: cir.func @pass_gt_128(%arg0: !cir.ptr<!rec_GT_128>
 // CHECK:   %[[#V0:]] = cir.alloca !cir.ptr<!rec_GT_128>, !cir.ptr<!cir.ptr<!rec_GT_128>>, [""] {alignment = 8 : i64}
 // CHECK:   cir.store{{.*}} %arg0, %[[#V0]] : !cir.ptr<!rec_GT_128>, !cir.ptr<!cir.ptr<!rec_GT_128>>
-// CHECK:   %[[#V1:]] = cir.load %[[#V0]] : !cir.ptr<!cir.ptr<!rec_GT_128>>, !cir.ptr<!rec_GT_128>
+// CHECK:   %[[#V1:]] = cir.load{{.*}} %[[#V0]] : !cir.ptr<!cir.ptr<!rec_GT_128>>, !cir.ptr<!rec_GT_128>
 
 // LLVM: void @pass_gt_128(ptr %0)
 // LLVM:   %[[#V1:]] = alloca ptr, i64 1, align 8
@@ -156,7 +156,7 @@ void pass_gt_128(GT_128 s) {}
 // CHECK: cir.func @get_gt_128(%arg0: !cir.ptr<!rec_GT_128> {{.*}}, %arg1: !cir.ptr<!rec_GT_128>
 // CHECK: %[[#V0:]] = cir.alloca !cir.ptr<!rec_GT_128>, !cir.ptr<!cir.ptr<!rec_GT_128>>, [""] {alignment = 8 : i64}
 // CHECK: cir.store{{.*}} %arg1, %[[#V0]] : !cir.ptr<!rec_GT_128>, !cir.ptr<!cir.ptr<!rec_GT_128>>
-// CHECK: %[[#V1:]] = cir.load %[[#V0]] : !cir.ptr<!cir.ptr<!rec_GT_128>>, !cir.ptr<!rec_GT_128>
+// CHECK: %[[#V1:]] = cir.load{{.*}} %[[#V0]] : !cir.ptr<!cir.ptr<!rec_GT_128>>, !cir.ptr<!rec_GT_128>
 // CHECK: cir.copy %[[#V1]] to %arg0 : !cir.ptr<!rec_GT_128>
 // CHECK: cir.return
 
@@ -172,7 +172,7 @@ GT_128 get_gt_128(GT_128 s) {
 
 // CHECK: cir.func no_proto @call_and_get_gt_128(%arg0: !cir.ptr<!rec_GT_128>
 // CHECK: %[[#V0:]] = cir.alloca !rec_GT_128, !cir.ptr<!rec_GT_128>, ["tmp"] {alignment = 8 : i64}
-// CHECK: %[[#V1:]] = cir.load %arg0 : !cir.ptr<!rec_GT_128>, !rec_GT_128
+// CHECK: %[[#V1:]] = cir.load{{.*}} %arg0 : !cir.ptr<!rec_GT_128>, !rec_GT_128
 // CHECK: %[[#V2:]] = cir.alloca !rec_GT_128, !cir.ptr<!rec_GT_128>, [""] {alignment = 8 : i64}
 // CHECK: %[[#V3:]] = cir.alloca !rec_GT_128, !cir.ptr<!rec_GT_128>, ["tmp"] {alignment = 8 : i64}
 // CHECK: %[[#V4:]] = cir.cast(bitcast, %arg0 : !cir.ptr<!rec_GT_128>), !cir.ptr<!void>
@@ -213,12 +213,12 @@ void passS(S s) {}
 // CHECK: @callS()
 // CHECK: %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s"] {alignment = 4 : i64}
 // CHECK: %[[#V1:]] = cir.alloca !cir.array<!u64i x 2>, !cir.ptr<!cir.array<!u64i x 2>>, ["tmp"] {alignment = 8 : i64}
-// CHECK: %[[#V2:]] = cir.load %[[#V0]] : !cir.ptr<!rec_S>, !rec_S
+// CHECK: %[[#V2:]] = cir.load{{.*}} %[[#V0]] : !cir.ptr<!rec_S>, !rec_S
 // CHECK: %[[#V3:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!void>
 // CHECK: %[[#V4:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>), !cir.ptr<!void>
 // CHECK: %[[#V5:]] = cir.const #cir.int<12> : !u64i
 // CHECK: cir.libc.memcpy %[[#V5]] bytes from %[[#V3]] to %[[#V4]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
-// CHECK: %[[#V6:]] = cir.load %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
+// CHECK: %[[#V6:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>, !cir.array<!u64i x 2>
 // CHECK: cir.call @passS(%[[#V6]]) : (!cir.array<!u64i x 2>) -> ()
 // CHECK: cir.return
 
@@ -243,13 +243,13 @@ typedef struct {
 
 // CHECK: cir.func {{.*@ret_s_pad}}()  -> !u48i
 // CHECK: %[[#V0:]] = cir.alloca !rec_S_PAD, !cir.ptr<!rec_S_PAD>, ["__retval"] {alignment = 2 : i64}
-// CHECK: %[[#V1:]] = cir.load %[[#V0]] : !cir.ptr<!rec_S_PAD>, !rec_S_PAD
+// CHECK: %[[#V1:]] = cir.load{{.*}} %[[#V0]] : !cir.ptr<!rec_S_PAD>, !rec_S_PAD
 // CHECK: %[[#V2:]] = cir.alloca !u48i, !cir.ptr<!u48i>, [""] {alignment = 2 : i64}
 // CHECK: %[[#V3:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S_PAD>)
 // CHECK: %[[#V4:]] = cir.cast(bitcast, %[[#V2:]] : !cir.ptr<!u48i>), !cir.ptr<!void>
 // CHECK: %[[#V5:]] = cir.const #cir.int<6> : !u64i
 // CHECK: cir.libc.memcpy %[[#V5]] bytes from %[[#V3]] to %[[#V4]] : !u64i, !cir.ptr<!void>
-// CHECK: %[[#V6:]] = cir.load %[[#V2]] : !cir.ptr<!u48i>
+// CHECK: %[[#V6:]] = cir.load{{.*}} %[[#V2]] : !cir.ptr<!u48i>
 // CHECK: cir.return %[[#V6]]
 
 // LLVM: i48 @ret_s_pad()
@@ -271,7 +271,7 @@ typedef struct {
 // CHECK: cir.func @pass_cat(%arg0: !cir.ptr<!rec_CAT>
 // CHECK: %[[#V0:]]  = cir.alloca !cir.ptr<!rec_CAT>, !cir.ptr<!cir.ptr<!rec_CAT>>, [""] {alignment = 8 : i64}
 // CHECK: cir.store{{.*}} %arg0, %[[#V0]]  : !cir.ptr<!rec_CAT>, !cir.ptr<!cir.ptr<!rec_CAT>>
-// CHECK: %[[#V1:]]  = cir.load %[[#V0]]  : !cir.ptr<!cir.ptr<!rec_CAT>>, !cir.ptr<!rec_CAT>
+// CHECK: %[[#V1:]]  = cir.load{{.*}} %[[#V0]]  : !cir.ptr<!cir.ptr<!rec_CAT>>, !cir.ptr<!rec_CAT>
 // CHECK: cir.return
 
 // LLVM: void @pass_cat(ptr %[[#V0:]])
@@ -307,16 +307,16 @@ void pass_nested_u(NESTED_U a) {}
 // CHECK: cir.func no_proto @call_nested_u()
 // CHECK: %[[#V0:]] = cir.alloca !rec_NESTED_U, !cir.ptr<!rec_NESTED_U>
 // CHECK: %[[#V1:]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["tmp"]
-// CHECK: %[[#V2:]] = cir.load %[[#V0]] : !cir.ptr<!rec_NESTED_U>, !rec_NESTED_U
+// CHECK: %[[#V2:]] = cir.load{{.*}} %[[#V0]] : !cir.ptr<!rec_NESTED_U>, !rec_NESTED_U
 // CHECK: %[[#V3:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_NESTED_U>), !cir.ptr<!rec_anon2E0>
-// CHECK: %[[#V4:]] = cir.load %[[#V3]] : !cir.ptr<!rec_anon2E0>, !rec_anon2E0
+// CHECK: %[[#V4:]] = cir.load{{.*}} %[[#V3]] : !cir.ptr<!rec_anon2E0>, !rec_anon2E0
 // CHECK: %[[#V5:]] = cir.cast(bitcast, %[[#V3]] : !cir.ptr<!rec_anon2E0>), !cir.ptr<!rec_anon2E1>
-// CHECK: %[[#V6:]] = cir.load %[[#V5]] : !cir.ptr<!rec_anon2E1>, !rec_anon2E1
+// CHECK: %[[#V6:]] = cir.load{{.*}} %[[#V5]] : !cir.ptr<!rec_anon2E1>, !rec_anon2E1
 // CHECK: %[[#V7:]] = cir.cast(bitcast, %[[#V5]] : !cir.ptr<!rec_anon2E1>), !cir.ptr<!void>
 // CHECK: %[[#V8:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!u64i>), !cir.ptr<!void>
 // CHECK: %[[#V9:]] = cir.const #cir.int<2> : !u64i
 // CHECK: cir.libc.memcpy %[[#V9]] bytes from %[[#V7]] to %[[#V8]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
-// CHECK: %[[#V10:]] = cir.load %[[#V1]] : !cir.ptr<!u64i>, !u64i
+// CHECK: %[[#V10:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!u64i>, !u64i
 // CHECK: cir.call @pass_nested_u(%[[#V10]]) : (!u64i) -> ()
 
 // LLVM: void @call_nested_u()
@@ -402,7 +402,7 @@ void qux(void) {
 // CHECK: %[[#V4:]] = cir.cast(array_to_ptrdecay, %[[#V2]] : !cir.ptr<!cir.array<!rec_PackedS2 x 3>>), !cir.ptr<!rec_PackedS2>
 // CHECK: %[[#V5:]] = cir.ptr_stride(%[[#V4]] : !cir.ptr<!rec_PackedS2>, %[[#V3]] : !s32i), !cir.ptr<!rec_PackedS2>
 // CHECK: cir.store{{.*}} %[[#V5]], %[[#V0]] : !cir.ptr<!rec_PackedS2>, !cir.ptr<!cir.ptr<!rec_PackedS2>>
-// CHECK: %[[#V6:]] = cir.load deref %[[#V0]] : !cir.ptr<!cir.ptr<!rec_PackedS2>>, !cir.ptr<!rec_PackedS2>
+// CHECK: %[[#V6:]] = cir.load deref{{.*}}  %[[#V0]] : !cir.ptr<!cir.ptr<!rec_PackedS2>>, !cir.ptr<!rec_PackedS2>
 // CHECK: %[[#V7:]] = cir.cast(bitcast, %[[#V6]] : !cir.ptr<!rec_PackedS2>), !cir.ptr<!void>  
 // CHECK: %[[#V8:]] = cir.const #cir.int<6> : !u64i
 // CHECK: cir.libc.memcpy %[[#V8]] bytes from %[[#V7]] 
diff --git a/clang/test/CIR/CallConvLowering/x86_64/basic.cpp b/clang/test/CIR/CallConvLowering/x86_64/basic.cpp
index eea151f5b9f2..fc38ef659a6e 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/basic.cpp
+++ b/clang/test/CIR/CallConvLowering/x86_64/basic.cpp
@@ -109,7 +109,7 @@ S1 s1(S1 arg) {
 
   /// Cast argument and result of the function call to the expected types.
   // CHECK: %[[#V9:]] = cir.cast(bitcast, %[[#V3]] : !cir.ptr<!rec_S1>), !cir.ptr<!u64i>
-  // CHECK: %[[#V10:]] = cir.load %[[#V9]] : !cir.ptr<!u64i>, !u64i
+  // CHECK: %[[#V10:]] = cir.load{{.*}} %[[#V9]] : !cir.ptr<!u64i>, !u64i
   // CHECK: %[[#V11:]] = cir.call @_Z2s12S1(%[[#V10]]) : (!u64i) -> !u64i
   // CHECK: %[[#V12:]] = cir.cast(bitcast, %[[#V4]] : !cir.ptr<!rec_S1>), !cir.ptr<!u64i>
   // CHECK: cir.store{{.*}} %[[#V11]], %[[#V12]] : !u64i, !cir.ptr<!u64i>
@@ -122,7 +122,7 @@ S1 s1(S1 arg) {
   // CHECK: %[[#V16:]] = cir.const #cir.int<2> : !s32i
   // CHECK: cir.store{{.*}} %[[#V16]], %[[#V15]] : !s32i, !cir.ptr<!s32i>
   // CHECK: %[[#V17:]] = cir.cast(bitcast, %[[#V2]] : !cir.ptr<!rec_S1>), !cir.ptr<!u64i>
-  // CHECK: %[[#V18:]] = cir.load %[[#V17]] : !cir.ptr<!u64i>, !u64i
+  // CHECK: %[[#V18:]] = cir.load{{.*}} %[[#V17]] : !cir.ptr<!u64i>, !u64i
   // CHECK: cir.return %[[#V18]] : !u64i
   return {1, 2};
 }
@@ -170,7 +170,7 @@ S2 s2(S2 arg) {
   // COM: Flattening of the struct.
   // COM: { i32, i32, i32 } -> { i64, i32 }.
 
-  // CHECK: %[[#F20:]] = cir.load %[[#F8]] : !cir.ptr<!rec_S2>, !rec_S2
+  // CHECK: %[[#F20:]] = cir.load{{.*}} %[[#F8]] : !cir.ptr<!rec_S2>, !rec_S2
   // CHECK: cir.store{{.*}} %[[#F20]], %[[#F11]] : !rec_S2, !cir.ptr<!rec_S2>
   // CHECK: %[[#F21:]] = cir.cast(bitcast, %[[#F11]] : !cir.ptr<!rec_S2>), !cir.ptr<!void>
   // CHECK: %[[#F22:]] = cir.cast(bitcast, %[[#F10]] : !cir.ptr<!rec_anon_struct>), !cir.ptr<!void>
@@ -181,9 +181,9 @@ S2 s2(S2 arg) {
   // COM: Retrieve the two values in { i64, i32 }.
 
   // CHECK: %[[#F24:]] = cir.get_member %[[#F10]][0] {name = ""} : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!u64i>
-  // CHECK: %[[#F25:]] = cir.load %[[#F24]] : !cir.ptr<!u64i>, !u64i
+  // CHECK: %[[#F25:]] = cir.load{{.*}} %[[#F24]] : !cir.ptr<!u64i>, !u64i
   // CHECK: %[[#F26:]] = cir.get_member %[[#F10]][1] {name = ""} : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!s32i>
-  // CHECK: %[[#F27:]] = cir.load %[[#F26]] : !cir.ptr<!s32i>, !s32i
+  // CHECK: %[[#F27:]] = cir.load{{.*}} %[[#F26]] : !cir.ptr<!s32i>, !s32i
   // CHECK: %[[#F28:]] = cir.call @_Z2s22S2(%[[#F25]], %[[#F27]]) : (!u64i, !s32i) -> !rec_anon_struct
   // CHECK: cir.store{{.*}} %[[#F28]], %[[#F12]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
 
@@ -201,7 +201,7 @@ S2 s2(S2 arg) {
   // CHECK: %[[#F40:]] = cir.cast(bitcast, %[[#F13]] : !cir.ptr<!rec_anon_struct>), !cir.ptr<!void>
   // CHECK: %[[#F41:]] = cir.const #cir.int<12> : !u64i
   // cir.libc.memcpy %[[#F41]] bytes from %[[#F39]] to %[[#F40]]
-  // CHECK: %[[#F42:]] = cir.load %[[#F13]] : !cir.ptr<!rec_anon_struct>, !rec_anon_struct
+  // CHECK: %[[#F42:]] = cir.load{{.*}} %[[#F13]] : !cir.ptr<!rec_anon_struct>, !rec_anon_struct
   // cir.return %[[#F42]] : !rec_anon_struct
   s2({ 1, 2, 3 });
   return { 1, 2, 3 };
diff --git a/clang/test/CIR/CallConvLowering/x86_64/fptrs.c b/clang/test/CIR/CallConvLowering/x86_64/fptrs.c
index 0f60b7ddb54c..3ec9ed4b8f4f 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/fptrs.c
+++ b/clang/test/CIR/CallConvLowering/x86_64/fptrs.c
@@ -26,9 +26,9 @@ void bar() {
 // CHECK:   %[[#V3:]] = cir.get_global @foo : !cir.ptr<!cir.func<(!s32i) -> !s32i>>
 // CHECK:   %[[#V4:]] = cir.cast(bitcast, %[[#V3]] : !cir.ptr<!cir.func<(!s32i) -> !s32i>>), !cir.ptr<!cir.func<(!rec_S) -> !s32i>>
 // CHECK:   cir.store{{.*}} %[[#V4]], %[[#V2]] : !cir.ptr<!cir.func<(!rec_S) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!rec_S) -> !s32i>>>
-// CHECK:   %[[#V5:]] = cir.load %[[#V2]] : !cir.ptr<!cir.ptr<!cir.func<(!rec_S) -> !s32i>>>, !cir.ptr<!cir.func<(!rec_S) -> !s32i>>
+// CHECK:   %[[#V5:]] = cir.load{{.*}} %[[#V2]] : !cir.ptr<!cir.ptr<!cir.func<(!rec_S) -> !s32i>>>, !cir.ptr<!cir.func<(!rec_S) -> !s32i>>
 // CHECK:   %[[#V6:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!s32i>
-// CHECK:   %[[#V7:]] = cir.load %[[#V6]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[#V7:]] = cir.load{{.*}} %[[#V6]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[#V8:]] = cir.cast(bitcast, %[[#V5]] : !cir.ptr<!cir.func<(!rec_S) -> !s32i>>), !cir.ptr<!cir.func<(!s32i) -> !s32i>>
 // CHECK:   %[[#V9:]] = cir.call %[[#V8]](%[[#V7]]) : (!cir.ptr<!cir.func<(!s32i) -> !s32i>>, !s32i) -> !s32i
 
diff --git a/clang/test/CIR/CallConvLowering/x86_64/int128.cpp b/clang/test/CIR/CallConvLowering/x86_64/int128.cpp
index 8d8dadd5dae0..5f9cff51d521 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/int128.cpp
+++ b/clang/test/CIR/CallConvLowering/x86_64/int128.cpp
@@ -35,8 +35,8 @@ __int128 test1(__int128 a, __int128 b) {
   // LLVM-NEXT: %[[#RET_SLOT:]] = alloca i128, i64 1, align 16
 
   return a + b;
-  //      CHECK: %[[#A:]] = cir.load %[[#SLOT_A]] : !cir.ptr<!s128i>, !s128i
-  // CHECK-NEXT: %[[#B:]] = cir.load %[[#SLOT_B]] : !cir.ptr<!s128i>, !s128i
+  //      CHECK: %[[#A:]] = cir.load{{.*}} %[[#SLOT_A]] : !cir.ptr<!s128i>, !s128i
+  // CHECK-NEXT: %[[#B:]] = cir.load{{.*}} %[[#SLOT_B]] : !cir.ptr<!s128i>, !s128i
   // CHECK-NEXT: %[[#SUM:]] = cir.binop(add, %[[#A]], %[[#B]]) nsw : !s128i
   // CHECK-NEXT: cir.store %[[#SUM]], %[[#SLOT_RET]] : !s128i, !cir.ptr<!s128i>
 
@@ -46,7 +46,7 @@ __int128 test1(__int128 a, __int128 b) {
   // LLVM-NEXT: store i128 %[[#SUM]], ptr %[[#RET_SLOT]], align 16
 
   //      CHECK: %[[#SLOT_RET2:]] = cir.cast(bitcast, %[[#SLOT_RET]] : !cir.ptr<!s128i>), !cir.ptr<![[I128_STRUCT]]>
-  // CHECK-NEXT: %[[#RET:]] = cir.load %[[#SLOT_RET2]] : !cir.ptr<![[I128_STRUCT]]>, ![[I128_STRUCT]]
+  // CHECK-NEXT: %[[#RET:]] = cir.load{{.*}} %[[#SLOT_RET2]] : !cir.ptr<![[I128_STRUCT]]>, ![[I128_STRUCT]]
   // CHECK-NEXT: cir.return %[[#RET]] : ![[I128_STRUCT]]
 
   //      LLVM: %[[#RET:]] = load { i64, i64 }, ptr %[[#RET_SLOT]], align 8
diff --git a/clang/test/CIR/CodeGen/AArch64/neon-arith.c b/clang/test/CIR/CodeGen/AArch64/neon-arith.c
index 083b7a61897e..ebcca6b1b2a5 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon-arith.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon-arith.c
@@ -22,16 +22,16 @@ float32_t test_vrndns_f32(float32_t a) {
 }
 // CIR: cir.func internal private @vrndns_f32(%arg0: !cir.float {{.*}}) -> !cir.float
 // CIR: cir.store %arg0, [[ARG_SAVE:%.*]] : !cir.float, !cir.ptr<!cir.float> 
-// CIR: [[INTRIN_ARG:%.*]] = cir.load [[ARG_SAVE]] : !cir.ptr<!cir.float>, !cir.float 
+// CIR: [[INTRIN_ARG:%.*]] = cir.load{{.*}} [[ARG_SAVE]] : !cir.ptr<!cir.float>, !cir.float 
 // CIR: {{%.*}} = cir.roundeven [[INTRIN_ARG]] : !cir.float
 // CIR: cir.return {{%.*}} : !cir.float
 
 // CIR-LABEL: test_vrndns_f32
 // CIR: cir.store %arg0, [[ARG_SAVE0:%.*]] : !cir.float, !cir.ptr<!cir.float> 
-// CIR: [[FUNC_ARG:%.*]] = cir.load [[ARG_SAVE]] : !cir.ptr<!cir.float>, !cir.float 
+// CIR: [[FUNC_ARG:%.*]] = cir.load{{.*}} [[ARG_SAVE]] : !cir.ptr<!cir.float>, !cir.float 
 // CIR: [[FUNC_RES:%.*]] = cir.call @vrndns_f32([[FUNC_ARG]]) : (!cir.float) -> !cir.float
 // CIR: cir.store [[FUNC_RES]], [[RET_P:%.*]] : !cir.float, !cir.ptr<!cir.float>
-// CIR: [[RET_VAL:%.*]] = cir.load [[RET_P]] : !cir.ptr<!cir.float>, !cir.float
+// CIR: [[RET_VAL:%.*]] = cir.load{{.*}} [[RET_P]] : !cir.ptr<!cir.float>, !cir.float
 // CIR: cir.return [[RET_VAL]] : !cir.float loc
 
 // LLVM: {{.*}}test_vrndns_f32(float{{.*}}[[ARG:%.*]])
@@ -44,7 +44,7 @@ float32x2_t test_vrnda_f32(float32x2_t a) {
 
 // CIR: cir.func internal private @vrnda_f32(%arg0: !cir.vector<!cir.float x 2>
 // CIR: cir.store %arg0, [[ARG_SAVE:%.*]] : !cir.vector<!cir.float x 2>, !cir.ptr<!cir.vector<!cir.float x 2>>
-// CIR: [[INTRIN_ARG:%.*]] = cir.load [[ARG_SAVE]] : !cir.ptr<!cir.vector<!cir.float x 2>>, !cir.vector<!cir.float x 2>
+// CIR: [[INTRIN_ARG:%.*]] = cir.load{{.*}} [[ARG_SAVE]] : !cir.ptr<!cir.vector<!cir.float x 2>>, !cir.vector<!cir.float x 2>
 // CIR: [[INTRIN_ARG_CAST:%.*]] = cir.cast(bitcast, [[INTRIN_ARG]] : !cir.vector<!cir.float x 2>), !cir.vector<!s8i x 8>
 // CIR: [[INTRIN_ARG_BACK:%.*]] = cir.cast(bitcast, [[INTRIN_ARG_CAST]] : !cir.vector<!s8i x 8>), !cir.vector<!cir.float x 2>
 // CIR: {{%.*}} = cir.round [[INTRIN_ARG_BACK]] : !cir.vector<!cir.float x 2>
@@ -52,10 +52,10 @@ float32x2_t test_vrnda_f32(float32x2_t a) {
 
 // CIR-LABEL: test_vrnda_f32
 // CIR: cir.store %arg0, [[ARG_SAVE0:%.*]] :  !cir.vector<!cir.float x 2>, !cir.ptr<!cir.vector<!cir.float x 2>> 
-// CIR: [[FUNC_ARG:%.*]] = cir.load [[ARG_SAVE]] : !cir.ptr<!cir.vector<!cir.float x 2>>, !cir.vector<!cir.float x 2> 
+// CIR: [[FUNC_ARG:%.*]] = cir.load{{.*}} [[ARG_SAVE]] : !cir.ptr<!cir.vector<!cir.float x 2>>, !cir.vector<!cir.float x 2> 
 // CIR: [[FUNC_RES:%.*]] = cir.call @vrnda_f32([[FUNC_ARG]]) : (!cir.vector<!cir.float x 2>) -> !cir.vector<!cir.float x 2>
 // CIR: cir.store [[FUNC_RES]], [[RET_P:%.*]] : !cir.vector<!cir.float x 2>, !cir.ptr<!cir.vector<!cir.float x 2>>
-// CIR: [[RET_VAL:%.*]] = cir.load [[RET_P]] : !cir.ptr<!cir.vector<!cir.float x 2>>, !cir.vector<!cir.float x 2>
+// CIR: [[RET_VAL:%.*]] = cir.load{{.*}} [[RET_P]] : !cir.ptr<!cir.vector<!cir.float x 2>>, !cir.vector<!cir.float x 2>
 // CIR: cir.return [[RET_VAL]] : !cir.vector<!cir.float x 2>
 
 // LLVM: {{.*}}test_vrnda_f32(<2 x float>{{.*}}[[ARG:%.*]])
@@ -68,7 +68,7 @@ float32x4_t test_vrndaq_f32(float32x4_t a) {
 
 // CIR: cir.func internal private @vrndaq_f32(%arg0: !cir.vector<!cir.float x 4>
 // CIR: cir.store %arg0, [[ARG_SAVE:%.*]] : !cir.vector<!cir.float x 4>, !cir.ptr<!cir.vector<!cir.float x 4>>
-// CIR: [[INTRIN_ARG:%.*]] = cir.load [[ARG_SAVE]] : !cir.ptr<!cir.vector<!cir.float x 4>>, !cir.vector<!cir.float x 4>
+// CIR: [[INTRIN_ARG:%.*]] = cir.load{{.*}} [[ARG_SAVE]] : !cir.ptr<!cir.vector<!cir.float x 4>>, !cir.vector<!cir.float x 4>
 // CIR: [[INTRIN_ARG_CAST:%.*]] = cir.cast(bitcast, [[INTRIN_ARG]] : !cir.vector<!cir.float x 4>), !cir.vector<!s8i x 16>
 // CIR: [[INTRIN_ARG_BACK:%.*]] = cir.cast(bitcast, [[INTRIN_ARG_CAST]] : !cir.vector<!s8i x 16>), !cir.vector<!cir.float x 4>
 // CIR: {{%.*}} = cir.round [[INTRIN_ARG_BACK]] : !cir.vector<!cir.float x 4>
diff --git a/clang/test/CIR/CodeGen/AArch64/neon-misc.c b/clang/test/CIR/CodeGen/AArch64/neon-misc.c
index 2aad156caa0c..581b639d8dc2 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon-misc.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon-misc.c
@@ -1391,7 +1391,7 @@ int8x8_t test_splat_lane_s8(int8x8_t v) {
   return (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)v, 7, 0);
 
   // CIR-LABEL: test_splat_lane_s8
-  // CIR: [[VEC:%.*]] = cir.load {{%.*}} : !cir.ptr<!cir.vector<!s8i x 8>>, !cir.vector<!s8i x 8>
+  // CIR: [[VEC:%.*]] = cir.load {{.*}} {{%.*}} : !cir.ptr<!cir.vector<!s8i x 8>>, !cir.vector<!s8i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[VEC]] : !cir.vector<!s8i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, 
   // CIR-SAME:  #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i] : !cir.vector<!s8i x 8>
@@ -1535,7 +1535,7 @@ int8x16_t test_splatq_lane_s8(int8x8_t v) {
   return (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 7, 0);
 
   // CIR-LABEL: test_splatq_lane_s8
-  // CIR: [[VEC:%.*]] = cir.load {{%.*}} : !cir.ptr<!cir.vector<!s8i x 8>>, !cir.vector<!s8i x 8>
+  // CIR: [[VEC:%.*]] = cir.load {{.*}} {{%.*}} : !cir.ptr<!cir.vector<!s8i x 8>>, !cir.vector<!s8i x 8>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[VEC]] : !cir.vector<!s8i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, 
   // CIR-SAME:  #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i,
@@ -1691,7 +1691,7 @@ int8x8_t test_splat_laneq_s8(int8x16_t v) {
   return (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 15, 32);
 
   // CIR-LABEL: test_splat_laneq_s8
-  // CIR: [[VEC:%.*]] = cir.load {{.*}} : !cir.ptr<!cir.vector<!s8i x 16>>, !cir.vector<!s8i x 16>
+  // CIR: [[VEC:%.*]] = cir.load {{.*}} {{.*}} : !cir.ptr<!cir.vector<!s8i x 16>>, !cir.vector<!s8i x 16>
   // CIR: cir.vec.shuffle([[VEC]], [[VEC]] : !cir.vector<!s8i x 16>)
   // CIR-SAME: [#cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i,
   // CIR-SAME:  #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i] : !cir.vector<!s8i x 8>
@@ -1841,7 +1841,7 @@ int8x16_t test_splatq_laneq_s8(int8x16_t v) {
   return (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 15, 32);
 
   // CIR-LABEL: test_splatq_laneq_s8
-  // CIR: [[VEC:%.*]] = cir.load {{.*}} : !cir.ptr<!cir.vector<!s8i x 16>>, !cir.vector<!s8i x 16>
+  // CIR: [[VEC:%.*]] = cir.load {{.*}} {{.*}} : !cir.ptr<!cir.vector<!s8i x 16>>, !cir.vector<!s8i x 16>
   // CIR: cir.vec.shuffle([[VEC]], [[VEC]] : !cir.vector<!s8i x 16>)
   // CIR-SAME: [#cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i,
   // CIR-SAME:  #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i,
diff --git a/clang/test/CIR/CodeGen/AArch64/neon.c b/clang/test/CIR/CodeGen/AArch64/neon.c
index d1dd4eae4256..ae7177770417 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon.c
@@ -14925,7 +14925,7 @@ int16_t test_vqmovns_s32(int32_t a) {
   return (int16_t)vqmovns_s32(a);
 
   // CIR-LABEL: vqmovns_s32
-  // CIR: [[A:%.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+  // CIR: [[A:%.*]] = cir.load{{.*}} : !cir.ptr<!s32i>, !s32i
   // CIR: [[VQMOVNS_S32_ZERO1:%.*]] = cir.const #cir.int<0> : !u64i
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !s32i
   // CIR: [[POISON_VEC:%.*]] = cir.vec.splat [[POISON]] : !s32i, !cir.vector<!s32i x 4>
@@ -19471,7 +19471,7 @@ uint8x8_t test_vld1_dup_u8(uint8_t const * ptr) {
 }
 
 // CIR-LABEL: vld1_dup_u8
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!u8i>, !u8i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!u8i>, !u8i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !u8i, !cir.vector<!u8i x 8>
 
 // LLVM: {{.*}}test_vld1_dup_u8(ptr{{.*}}[[PTR:%.*]])
@@ -19484,7 +19484,7 @@ int8x8_t test_vld1_dup_s8(int8_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_s8
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s8i>, !s8i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s8i>, !s8i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s8i, !cir.vector<!s8i x 8>
 
 // LLVM: {{.*}}test_vld1_dup_s8(ptr{{.*}}[[PTR:%.*]])
@@ -19497,7 +19497,7 @@ uint16x4_t test_vld1_dup_u16(uint16_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_u16
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!u16i>, !u16i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!u16i>, !u16i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !u16i, !cir.vector<!u16i x 4>
 
 // LLVM: {{.*}}test_vld1_dup_u16(ptr{{.*}}[[PTR:%.*]])
@@ -19510,7 +19510,7 @@ int16x4_t test_vld1_dup_s16(int16_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_s16
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s16i>, !s16i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s16i>, !s16i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s16i, !cir.vector<!s16i x 4>
 
 // LLVM: {{.*}}test_vld1_dup_s16(ptr{{.*}}[[PTR:%.*]])
@@ -19523,7 +19523,7 @@ int32x2_t test_vld1_dup_s32(int32_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_s32
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s32i, !cir.vector<!s32i x 2>
 
 // LLVM: {{.*}}test_vld1_dup_s32(ptr{{.*}}[[PTR:%.*]])
@@ -19536,7 +19536,7 @@ int64x1_t test_vld1_dup_s64(int64_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_s64
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s64i>, !s64i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s64i>, !s64i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s64i, !cir.vector<!s64i x 1>
 
 // LLVM: {{.*}}test_vld1_dup_s64(ptr{{.*}}[[PTR:%.*]])
@@ -19549,7 +19549,7 @@ float32x2_t test_vld1_dup_f32(float32_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_f32
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!cir.float>, !cir.float
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!cir.float>, !cir.float
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !cir.float, !cir.vector<!cir.float x 2>
 
 // LLVM: {{.*}}test_vld1_dup_f32(ptr{{.*}}[[PTR:%.*]])
@@ -19562,7 +19562,7 @@ float64x1_t test_vld1_dup_f64(float64_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1_dup_f64
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!cir.double>, !cir.double
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!cir.double>, !cir.double
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !cir.double, !cir.vector<!cir.double x 1>
 
 // LLVM: {{.*}}test_vld1_dup_f64(ptr{{.*}}[[PTR:%.*]])
@@ -19575,7 +19575,7 @@ uint8x16_t test_vld1q_dup_u8(uint8_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_u8
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!u8i>, !u8i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!u8i>, !u8i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !u8i, !cir.vector<!u8i x 16>
 
 // LLVM: {{.*}}test_vld1q_dup_u8(ptr{{.*}}[[PTR:%.*]])
@@ -19588,7 +19588,7 @@ int8x16_t test_vld1q_dup_s8(int8_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_s8
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s8i>, !s8i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s8i>, !s8i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s8i, !cir.vector<!s8i x 16>
 
 // LLVM: {{.*}}test_vld1q_dup_s8(ptr{{.*}}[[PTR:%.*]])
@@ -19601,7 +19601,7 @@ uint16x8_t test_vld1q_dup_u16(uint16_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_u16
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!u16i>, !u16i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!u16i>, !u16i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !u16i, !cir.vector<!u16i x 8>
 
 // LLVM: {{.*}}test_vld1q_dup_u16(ptr{{.*}}[[PTR:%.*]])
@@ -19614,7 +19614,7 @@ int16x8_t test_vld1q_dup_s16(int16_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_s16
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s16i>, !s16i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s16i>, !s16i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s16i, !cir.vector<!s16i x 8>
 
 // LLVM: {{.*}}test_vld1q_dup_s16(ptr{{.*}}[[PTR:%.*]])
@@ -19627,7 +19627,7 @@ int32x4_t test_vld1q_dup_s32(int32_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_s32
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s32i, !cir.vector<!s32i x 4>
 
 // LLVM: {{.*}}test_vld1q_dup_s32(ptr{{.*}}[[PTR:%.*]])
@@ -19640,7 +19640,7 @@ int64x2_t test_vld1q_dup_s64(int64_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_s64
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!s64i>, !s64i
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!s64i>, !s64i
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !s64i, !cir.vector<!s64i x 2>
 
 // LLVM: {{.*}}test_vld1q_dup_s64(ptr{{.*}}[[PTR:%.*]])
@@ -19653,7 +19653,7 @@ float32x4_t test_vld1q_dup_f32(float32_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_f32
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!cir.float>, !cir.float
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!cir.float>, !cir.float
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !cir.float, !cir.vector<!cir.float x 4>
 
 // LLVM: {{.*}}test_vld1q_dup_f32(ptr{{.*}}[[PTR:%.*]])
@@ -19666,7 +19666,7 @@ float64x2_t test_vld1q_dup_f64(float64_t const * ptr) {
 }
 
 // CIR-LABEL: test_vld1q_dup_f64
-// CIR: [[VAL:%.*]] = cir.load {{%.*}} : !cir.ptr<!cir.double>, !cir.double
+// CIR: [[VAL:%.*]] = cir.load{{.*}} {{%.*}} : !cir.ptr<!cir.double>, !cir.double
 // CIR: {{%.*}} = cir.vec.splat [[VAL]] : !cir.double, !cir.vector<!cir.double x 2>
 
 // LLVM: {{.*}}test_vld1q_dup_f64(ptr{{.*}}[[PTR:%.*]])
diff --git a/clang/test/CIR/CodeGen/CUDA/address-spaces.cu b/clang/test/CIR/CodeGen/CUDA/address-spaces.cu
index c1a5590ef106..89605735d393 100644
--- a/clang/test/CIR/CodeGen/CUDA/address-spaces.cu
+++ b/clang/test/CIR/CodeGen/CUDA/address-spaces.cu
@@ -15,5 +15,5 @@ __global__ void fn() {
 // CIR: cir.func @_Z2fnv
 // CIR: [[Local:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
 // CIR: [[Shared:%[0-9]+]] = cir.get_global @_ZZ2fnvE1j : !cir.ptr<!s32i, addrspace(offload_local)>
-// CIR: [[Tmp:%[0-9]+]] = cir.load [[Local]] : !cir.ptr<!s32i>, !s32i
+// CIR: [[Tmp:%[0-9]+]] = cir.load {{.*}} [[Local]] : !cir.ptr<!s32i>, !s32i
 // CIR: cir.store{{.*}} [[Tmp]], [[Shared]] : !s32i, !cir.ptr<!s32i, addrspace(offload_local)>
diff --git a/clang/test/CIR/CodeGen/OpenCL/global.cl b/clang/test/CIR/CodeGen/OpenCL/global.cl
index 9541480a6f58..ef5c63e58f83 100644
--- a/clang/test/CIR/CodeGen/OpenCL/global.cl
+++ b/clang/test/CIR/CodeGen/OpenCL/global.cl
@@ -18,7 +18,7 @@ constant int c[2] = {18, 21};
 kernel void test_get_global() {
   a = b;
   // CIR:      %[[#ADDRB:]] = cir.get_global @b : !cir.ptr<!s32i, addrspace(offload_global)>
-  // CIR-NEXT: %[[#LOADB:]] = cir.load %[[#ADDRB]] : !cir.ptr<!s32i, addrspace(offload_global)>, !s32i
+  // CIR-NEXT: %[[#LOADB:]] = cir.load{{.*}} %[[#ADDRB]] : !cir.ptr<!s32i, addrspace(offload_global)>, !s32i
   // CIR-NEXT: %[[#ADDRA:]] = cir.get_global @a : !cir.ptr<!s32i, addrspace(offload_global)>
   // CIR-NEXT: cir.store{{.*}} %[[#LOADB]], %[[#ADDRA]] : !s32i, !cir.ptr<!s32i, addrspace(offload_global)>
 
diff --git a/clang/test/CIR/CodeGen/OpenCL/static-vardecl.cl b/clang/test/CIR/CodeGen/OpenCL/static-vardecl.cl
index b2d6326c2419..88772183641a 100644
--- a/clang/test/CIR/CodeGen/OpenCL/static-vardecl.cl
+++ b/clang/test/CIR/CodeGen/OpenCL/static-vardecl.cl
@@ -16,7 +16,7 @@ kernel void test_static(int i) {
   // CIR-DAG: %[[#ADDRC:]] = cir.get_global @test_static.c : !cir.ptr<!s32i, addrspace(offload_local)>
 
   c = b;
-  // CIR:      %[[#LOADB:]] = cir.load %[[#ADDRB]] : !cir.ptr<!s32i, addrspace(offload_global)>, !s32i
+  // CIR:      %[[#LOADB:]] = cir.load{{.*}} %[[#ADDRB]] : !cir.ptr<!s32i, addrspace(offload_global)>, !s32i
   // CIR-NEXT: cir.store{{.*}} %[[#LOADB]], %[[#ADDRC]] : !s32i, !cir.ptr<!s32i, addrspace(offload_local)>
 
   // LLVM:     %[[#LOADB:]] = load i32, ptr addrspace(1) @test_static.b, align 4
diff --git a/clang/test/CIR/CodeGen/OpenMP/parallel.cpp b/clang/test/CIR/CodeGen/OpenMP/parallel.cpp
index d824165ce4f0..7b5d603cf979 100644
--- a/clang/test/CIR/CodeGen/OpenMP/parallel.cpp
+++ b/clang/test/CIR/CodeGen/OpenMP/parallel.cpp
@@ -18,7 +18,7 @@ void omp_parallel_2() {
 // CHECK-NEXT: %[[XVarDecl:.+]] = {{.*}} ["x", init]
 // CHECK-NEXT: %[[C1:.+]] = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT: cir.store{{.*}} %[[C1]], %[[XVarDecl]]
-// CHECK-NEXT: %[[XVal:.+]] = cir.load %[[XVarDecl]]
+// CHECK-NEXT: %[[XVal:.+]] = cir.load {{.*}} %[[XVarDecl]]
 // CHECK-NEXT: %[[COne:.+]] = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT: %[[BinOpVal:.+]] = cir.binop(add, %[[XVal]], %[[COne]])
 // CHECK-NEXT: cir.store{{.*}} %[[BinOpVal]], %[[YVarDecl]]
diff --git a/clang/test/CIR/CodeGen/String.cpp b/clang/test/CIR/CodeGen/String.cpp
index 95bf6d3243eb..51854ce910bf 100644
--- a/clang/test/CIR/CodeGen/String.cpp
+++ b/clang/test/CIR/CodeGen/String.cpp
@@ -20,7 +20,7 @@ void test() {
 //      CHECK: cir.func linkonce_odr @_ZN6StringC2Ev
 // CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!rec_String>
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0
-// CHECK-NEXT:   %1 = cir.load %0
+// CHECK-NEXT:   %1 = cir.load{{.*}} %0
 // CHECK-NEXT:   %2 = cir.get_member %1[0] {name = "storage"}
 // CHECK-NEXT:   %3 = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.store{{.*}} %3, %2 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
@@ -35,12 +35,12 @@ void test() {
 // CHECK-NEXT:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["size", init]
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0
 // CHECK-NEXT:   cir.store{{.*}} %arg1, %1
-// CHECK-NEXT:   %2 = cir.load %0
+// CHECK-NEXT:   %2 = cir.load{{.*}} %0
 // CHECK-NEXT:   %3 = cir.get_member %2[0] {name = "storage"}
 // CHECK-NEXT:   %4 = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.store{{.*}} %4, %3
 // CHECK-NEXT:   %5 = cir.get_member %2[1] {name = "size"} : !cir.ptr<!rec_String> -> !cir.ptr<!s64i>
-// CHECK-NEXT:   %6 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %6 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   %7 = cir.cast(integral, %6 : !s32i), !s64i
 // CHECK-NEXT:   cir.store{{.*}} %7, %5 : !s64i, !cir.ptr<!s64i>
 // CHECK-NEXT:   cir.return
@@ -51,7 +51,7 @@ void test() {
 // CHECK-NEXT:   %1 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["s", init] {alignment = 8 : i64}
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_String>, !cir.ptr<!cir.ptr<!rec_String>>
 // CHECK-NEXT:   cir.store{{.*}} %arg1, %1 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_String>>, !cir.ptr<!rec_String>
+// CHECK-NEXT:   %2 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_String>>, !cir.ptr<!rec_String>
 // CHECK-NEXT:   %3 = cir.get_member %2[0] {name = "storage"} : !cir.ptr<!rec_String> -> !cir.ptr<!cir.ptr<!s8i>>
 // CHECK-NEXT:   %4 = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.store{{.*}} %4, %3 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
@@ -62,8 +62,8 @@ void test() {
 // CHECK-NEXT:   %1 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["s", init] {alignment = 8 : i64}
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_String>, !cir.ptr<!cir.ptr<!rec_String>>
 // CHECK-NEXT:   cir.store{{.*}} %arg1, %1 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_String>>, !cir.ptr<!rec_String>
-// CHECK-NEXT:   %3 = cir.load %1 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+// CHECK-NEXT:   %2 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_String>>, !cir.ptr<!rec_String>
+// CHECK-NEXT:   %3 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
 // CHECK-NEXT:   cir.call @_ZN6StringC2EPKc(%2, %3) : (!cir.ptr<!rec_String>, !cir.ptr<!s8i>) -> ()
 // CHECK-NEXT:   cir.return
 
diff --git a/clang/test/CIR/CodeGen/abstract-cond.c b/clang/test/CIR/CodeGen/abstract-cond.c
index 01b9638e7fd3..50b54a150937 100644
--- a/clang/test/CIR/CodeGen/abstract-cond.c
+++ b/clang/test/CIR/CodeGen/abstract-cond.c
@@ -14,7 +14,7 @@ int f6(int a0, struct s6 a1, struct s6 a2) {
 // CIR:  %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1"
 // CIR:  %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2"
 // CIR:  %[[TMP:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["tmp"] {alignment = 4 : i64}
-// CIR:  %[[LOAD_A0:.*]] = cir.load %[[A0]] : !cir.ptr<!s32i>, !s32i
+// CIR:  %[[LOAD_A0:.*]] = cir.load{{.*}} %[[A0]] : !cir.ptr<!s32i>, !s32i
 // CIR:  %[[COND:.*]] = cir.cast(int_to_bool, %[[LOAD_A0]] : !s32i), !cir.bool
 // CIR:  cir.if %[[COND]] {
 // CIR:    cir.copy %[[A1]] to %[[TMP]] : !cir.ptr<!rec_s6>
diff --git a/clang/test/CIR/CodeGen/address-space-conversion.cpp b/clang/test/CIR/CodeGen/address-space-conversion.cpp
index eac5025375f6..be19335c24c3 100644
--- a/clang/test/CIR/CodeGen/address-space-conversion.cpp
+++ b/clang/test/CIR/CodeGen/address-space-conversion.cpp
@@ -14,7 +14,7 @@ using ri2_t = int __attribute__((address_space(2))) &;
 void test_ptr() {
   pi1_t ptr1;
   pi2_t ptr2 = (pi2_t)ptr1;
-  // CIR:      %[[#PTR1:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>, !cir.ptr<!s32i, addrspace(target<1>)>
+  // CIR:      %[[#PTR1:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>, !cir.ptr<!s32i, addrspace(target<1>)>
   // CIR-NEXT: %[[#CAST:]] = cir.cast(address_space, %[[#PTR1]] : !cir.ptr<!s32i, addrspace(target<1>)>), !cir.ptr<!s32i, addrspace(target<2>)>
   // CIR-NEXT: cir.store{{.*}} %[[#CAST]], %{{[0-9]+}} : !cir.ptr<!s32i, addrspace(target<2>)>, !cir.ptr<!cir.ptr<!s32i, addrspace(target<2>)>>
 
@@ -29,9 +29,9 @@ void test_ref() {
   pi1_t ptr;
   ri1_t ref1 = *ptr;
   ri2_t ref2 = (ri2_t)ref1;
-  // CIR:      %[[#DEREF:]] = cir.load deref %{{[0-9]+}} : !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>, !cir.ptr<!s32i, addrspace(target<1>)>
+  // CIR:      %[[#DEREF:]] = cir.load deref{{.*}}  %{{[0-9]+}} : !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>, !cir.ptr<!s32i, addrspace(target<1>)>
   // CIR-NEXT: cir.store{{.*}} %[[#DEREF]], %[[#ALLOCAREF1:]] : !cir.ptr<!s32i, addrspace(target<1>)>, !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>
-  // CIR-NEXT: %[[#REF1:]] = cir.load %[[#ALLOCAREF1]] : !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>, !cir.ptr<!s32i, addrspace(target<1>)>
+  // CIR-NEXT: %[[#REF1:]] = cir.load{{.*}} %[[#ALLOCAREF1]] : !cir.ptr<!cir.ptr<!s32i, addrspace(target<1>)>>, !cir.ptr<!s32i, addrspace(target<1>)>
   // CIR-NEXT: %[[#CAST:]] = cir.cast(address_space, %[[#REF1]] : !cir.ptr<!s32i, addrspace(target<1>)>), !cir.ptr<!s32i, addrspace(target<2>)>
   // CIR-NEXT: cir.store{{.*}} %[[#CAST]], %{{[0-9]+}} : !cir.ptr<!s32i, addrspace(target<2>)>, !cir.ptr<!cir.ptr<!s32i, addrspace(target<2>)>>
 
diff --git a/clang/test/CIR/CodeGen/agg-copy.c b/clang/test/CIR/CodeGen/agg-copy.c
index 0b1446fadfdf..5604f3f11382 100644
--- a/clang/test/CIR/CodeGen/agg-copy.c
+++ b/clang/test/CIR/CodeGen/agg-copy.c
@@ -14,10 +14,10 @@ typedef struct {
 // CHECK:   [[TMP1:%.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["a2", init]
 // CHECK:   cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
 // CHECK:   cir.store{{.*}} %arg1, [[TMP1]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
-// CHECK:   [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK:   [[TMP2:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK:   [[TMP3:%.*]] = cir.const #cir.int<1> : !s32i
 // CHECK:   [[TMP4:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<!rec_A>, [[TMP3]] : !s32i), !cir.ptr<!rec_A>
-// CHECK:   [[TMP5:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK:   [[TMP5:%.*]] = cir.load{{.*}} [[TMP1]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK:   [[TMP6:%.*]] = cir.const #cir.int<1> : !s32i
 // CHECK:   [[TMP7:%.*]] = cir.ptr_stride([[TMP5]] : !cir.ptr<!rec_A>, [[TMP6]] : !s32i), !cir.ptr<!rec_A>
 // CHECK:   cir.copy [[TMP7]] to [[TMP4]] : !cir.ptr<!rec_A>
@@ -30,9 +30,9 @@ void foo1(A* a1, A* a2) {
 // CHECK:    [[TMP1:%.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["a2", init]
 // CHECK:    cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
 // CHECK:    cir.store{{.*}} %arg1, [[TMP1]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
-// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK:    [[TMP2:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK:    [[TMP3:%.*]] = cir.get_member [[TMP2]][2] {name = "s"} : !cir.ptr<!rec_A> -> !cir.ptr<!rec_S>
-// CHECK:    [[TMP4:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK:    [[TMP4:%.*]] = cir.load{{.*}} [[TMP1]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK:    [[TMP5:%.*]] = cir.get_member [[TMP4]][2] {name = "s"} : !cir.ptr<!rec_A> -> !cir.ptr<!rec_S>
 // CHECK:    cir.copy [[TMP5]] to [[TMP3]] : !cir.ptr<!rec_S>
 void foo2(A* a1, A* a2) {
@@ -44,7 +44,7 @@ void foo2(A* a1, A* a2) {
 // CHECK:    [[TMP0]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["__retval"] {alignment = 4 : i64}
 // CHECK:    [[TMP1]] = cir.get_global @a : !cir.ptr<!rec_A>
 // CHECK:    cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr<!rec_A>
-// CHECK:    [[TMP2]] = cir.load [[TMP0]] : !cir.ptr<!rec_A>, !rec_A
+// CHECK:    [[TMP2]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!rec_A>, !rec_A
 // CHECK:    cir.return [[TMP2]] : !rec_A
 A a;
 A foo3(void) {
@@ -55,7 +55,7 @@ A foo3(void) {
 // CHECK:    [[TMP0]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["a1", init]
 // CHECK:    [[TMP1]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["a2", init]
 // CHECK:    cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
-// CHECK:    [[TMP2]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK:    [[TMP2]] = cir.load deref{{.*}}  [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK:    cir.copy [[TMP2]] to [[TMP1]] : !cir.ptr<!rec_A>
 void foo4(A* a1) {
     A a2 = *a1;
@@ -80,7 +80,7 @@ void foo6(A* a1) {
 // CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["a1", init] {alignment = 8 : i64}
 // CHECK:   [[TMP1:%.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["a2", init] {alignment = 4 : i64}
 // CHECK:   cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
-// CHECK:   [[TMP2:%.*]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK:   [[TMP2:%.*]] = cir.load deref{{.*}}  [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK:   cir.copy [[TMP2]] to [[TMP1]] : !cir.ptr<!rec_A>
 }
 
diff --git a/clang/test/CIR/CodeGen/align-load.c b/clang/test/CIR/CodeGen/align-load.c
new file mode 100644
index 000000000000..3d6f037e7be6
--- /dev/null
+++ b/clang/test/CIR/CodeGen/align-load.c
@@ -0,0 +1,80 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
+// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG
+ 
+struct S {
+  char b;
+  short s;
+  int i;
+  float f;
+  double d;
+};
+
+void accessStruct(struct S u) {
+  u.b;
+  u.s;
+  u.i;
+  u.f;
+  u.d;
+}
+
+// CIR: cir.func @accessStruct
+// CIR:   cir.load align(8)
+// CIR:   cir.load align(2)
+// CIR:   cir.load align(4)
+// CIR:   cir.load align(8)
+// CIR:   cir.load align(8)
+
+// LLVM: define{{.*}} @accessStruct
+// LLVM:   load i8, ptr {{.*}}, align 8
+// LLVM:   load i16, ptr {{.*}}, align 2
+// LLVM:   load i32, ptr {{.*}}, align 4
+// LLVM:   load float, ptr {{.*}}, align 8
+// LLVM:   load double, ptr {{.*}}, align 8
+
+// OGCG: define{{.*}} @accessStruct
+// OGCG:   load i8, ptr {{.*}}, align 8
+// OGCG:   load i16, ptr {{.*}}, align 2
+// OGCG:   load i32, ptr {{.*}}, align 4
+// OGCG:   load float, ptr {{.*}}, align 8
+// OGCG:   load double, ptr {{.*}}, align 8
+
+union U {
+  char b;
+  short s;
+  int i;
+  float f;
+  double d;
+};
+
+void accessUnion(union U u) {
+  u.b;
+  u.s;
+  u.i;
+  u.f;
+  u.d;
+}
+
+// CIR: cir.func @accessUnion
+// CIR:   cir.load align(8)
+// CIR:   cir.load align(8)
+// CIR:   cir.load align(8)
+// CIR:   cir.load align(8)
+// CIR:   cir.load align(8)
+
+// LLVM: define{{.*}} @accessUnion
+// LLVM:   load i8, ptr {{.*}}, align 8
+// LLVM:   load i16, ptr {{.*}}, align 8
+// LLVM:   load i32, ptr {{.*}}, align 8
+// LLVM:   load float, ptr {{.*}}, align 8
+// LLVM:   load double, ptr {{.*}}, align 8
+
+// OGCG: define{{.*}} @accessUnion
+// OGCG:   load i8, ptr {{.*}}, align 8
+// OGCG:   load i16, ptr {{.*}}, align 8
+// OGCG:   load i32, ptr {{.*}}, align 8
+// OGCG:   load float, ptr {{.*}}, align 8
+// OGCG:   load double, ptr {{.*}}, align 8
diff --git a/clang/test/CIR/CodeGen/array-init.c b/clang/test/CIR/CodeGen/array-init.c
index 6a3b5268468b..661873860672 100644
--- a/clang/test/CIR/CodeGen/array-init.c
+++ b/clang/test/CIR/CodeGen/array-init.c
@@ -21,7 +21,7 @@ void buz(int x) {
 // CIR-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr<!cir.array<!rec_T x 2>>), !cir.ptr<!rec_T>
 // CIR-NEXT: [[A_STORAGE0:%.*]] = cir.get_member [[FI_EL]][0] {name = "a"} : !cir.ptr<!rec_T> -> !cir.ptr<!s32i>
 // CIR-NEXT: [[B_STORAGE0:%.*]] = cir.get_member [[FI_EL]][1] {name = "b"} : !cir.ptr<!rec_T> -> !cir.ptr<!s64i>
-// CIR-NEXT: [[X_VAL:%.*]] = cir.load [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: [[X_VAL:%.*]] = cir.load{{.*}} [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: [[X_CASTED:%.*]] = cir.cast(integral, [[X_VAL]] : !s32i), !s64i
 // CIR-NEXT: cir.store{{.*}} [[X_CASTED]], [[B_STORAGE0]] : !s64i, !cir.ptr<!s64i>
 // CIR-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
@@ -47,15 +47,15 @@ void bar(int a, int b, int c) {
 // CIR-NEXT: cir.store{{.*}} %arg1, [[B:%.*]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: cir.store{{.*}} %arg2, [[C:%.*]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
-// CIR-NEXT: [[LOAD_A:%.*]] = cir.load [[A]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: [[LOAD_A:%.*]] = cir.load{{.*}} [[A]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.store{{.*}} [[LOAD_A]], [[FI_EL]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
 // CIR-NEXT: [[SE_EL:%.*]] = cir.ptr_stride(%4 : !cir.ptr<!s32i>, [[ONE]] : !s64i), !cir.ptr<!s32i>
-// CIR-NEXT: [[LOAD_B:%.*]] = cir.load [[B]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: [[LOAD_B:%.*]] = cir.load{{.*}} [[B]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.store{{.*}} [[LOAD_B]], [[SE_EL]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[TWO:%.*]] = cir.const #cir.int<2> : !s64i
 // CIR-NEXT: [[TH_EL:%.*]] = cir.ptr_stride(%4 : !cir.ptr<!s32i>, [[TWO]] : !s64i), !cir.ptr<!s32i>
-// CIR-NEXT: [[LOAD_C:%.*]] = cir.load [[C]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: [[LOAD_C:%.*]] = cir.load{{.*}} [[C]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.store{{.*}} [[LOAD_C]], [[TH_EL]] : !s32i, !cir.ptr<!s32i>
 
 void zero_init(int x) {
@@ -67,7 +67,7 @@ void zero_init(int x) {
 // CIR:    [[TEMP:%.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arrayinit.temp", init] {alignment = 8 : i64}
 // CIR:    cir.store{{.*}} %arg0, [[VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[BEGIN:%.*]] = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
-// CIR:    [[VAR:%.*]] = cir.load [[VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
+// CIR:    [[VAR:%.*]] = cir.load{{.*}} [[VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.store{{.*}} [[VAR]], [[BEGIN]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
 // CIR:    [[ZERO_INIT_START:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[ONE]] : !s64i), !cir.ptr<!s32i>
@@ -75,7 +75,7 @@ void zero_init(int x) {
 // CIR:    [[SIZE:%.*]] = cir.const #cir.int<3> : !s64i
 // CIR:    [[END:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[SIZE]] : !s64i), !cir.ptr<!s32i>
 // CIR:    cir.do {
-// CIR:      [[CUR:%.*]] = cir.load [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR:      [[CUR:%.*]] = cir.load{{.*}} [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR:      [[FILLER:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR:      cir.store{{.*}} [[FILLER]], [[CUR]] : !s32i, !cir.ptr<!s32i>
 // CIR:      [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
@@ -83,7 +83,7 @@ void zero_init(int x) {
 // CIR:      cir.store{{.*}} [[NEXT]], [[TEMP]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CIR:      cir.yield
 // CIR:    } while {
-// CIR:      [[CUR:%.*]] = cir.load [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR:      [[CUR:%.*]] = cir.load{{.*}} [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR:      [[CMP:%.*]] = cir.cmp(ne, [[CUR]], [[END]]) : !cir.ptr<!s32i>, !cir.bool
 // CIR:      cir.condition([[CMP]])
 // CIR:    }
@@ -112,7 +112,7 @@ void aggr_init() {
 // CIR:    cir.store{{.*}} %11, %10 : !s32i, !cir.ptr<!s32i>
 // CIR:    [[THREE:%.*]] = cir.const #cir.int<3> : !s64i
 // CIR:    %13 = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[THREE]] : !s64i), !cir.ptr<!s32i>
-// CIR:    [[VAR:%.*]] = cir.load [[VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
+// CIR:    [[VAR:%.*]] = cir.load{{.*}} [[VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.store{{.*}} [[VAR]], %13 : !s32i, !cir.ptr<!s32i>
 // CIR:    [[ONE_VAR:%.*]] = cir.const #cir.int<1> : !s64i
 // CIR:    %16 = cir.ptr_stride(%13 : !cir.ptr<!s32i>, [[ONE_VAR]] : !s64i), !cir.ptr<!s32i>
@@ -120,7 +120,7 @@ void aggr_init() {
 // CIR:    [[SIZE:%.*]] = cir.const #cir.int<5> : !s64i
 // CIR:    [[END:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[SIZE]] : !s64i), !cir.ptr<!s32i>
 // CIR:    cir.do {
-// CIR:      [[CUR:%.*]] = cir.load [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR:      [[CUR:%.*]] = cir.load{{.*}} [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR:      [[FILLER:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR:      cir.store{{.*}} [[FILLER]], [[CUR]] : !s32i, !cir.ptr<!s32i>
 // CIR:      [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
@@ -128,7 +128,7 @@ void aggr_init() {
 // CIR:      cir.store{{.*}} [[NEXT]], [[TEMP]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CIR:      cir.yield
 // CIR:    } while {
-// CIR:      [[CUR:%.*]] = cir.load [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR:      [[CUR:%.*]] = cir.load{{.*}} [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR:      [[CMP:%.*]] = cir.cmp(ne, [[CUR]], [[END]]) : !cir.ptr<!s32i>, !cir.bool
 // CIR:      cir.condition([[CMP]])
 // CIR:    }
diff --git a/clang/test/CIR/CodeGen/array-init.cpp b/clang/test/CIR/CodeGen/array-init.cpp
index ca621770666a..78a7ec6ce422 100644
--- a/clang/test/CIR/CodeGen/array-init.cpp
+++ b/clang/test/CIR/CodeGen/array-init.cpp
@@ -24,7 +24,7 @@ void foo() {
 // CHECK: %[[VAL_6:.*]] = cir.const #cir.int<2> : !s64i
 // CHECK: %[[VAL_7:.*]] = cir.ptr_stride(%[[VAL_5]] : !cir.ptr<!s32i>, %[[VAL_6]] : !s64i), !cir.ptr<!s32i>
 // CHECK: cir.do {
-// CHECK:     %[[VAL_8:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:     %[[VAL_8:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:     %[[VAL_9:.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:     cir.store{{.*}} %[[VAL_9]], %[[VAL_8]] : !s32i, !cir.ptr<!s32i>
 // CHECK:     %[[VAL_10:.*]] = cir.const #cir.int<1> : !s64i
@@ -32,7 +32,7 @@ void foo() {
 // CHECK:     cir.store{{.*}} %[[VAL_11]], %[[VAL_1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CHECK:     cir.yield
 // CHECK: } while {
-// CHECK:     %[[VAL_8:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:     %[[VAL_8:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:     %[[VAL_9:.*]] = cir.cmp(ne, %[[VAL_8]], %[[VAL_7]]) : !cir.ptr<!s32i>, !cir.bool
 // CHECK:     cir.condition(%[[VAL_9]])
 // CHECK: }
diff --git a/clang/test/CIR/CodeGen/array.c b/clang/test/CIR/CodeGen/array.c
index ccb5b2c4489f..ae2d9900448a 100644
--- a/clang/test/CIR/CodeGen/array.c
+++ b/clang/test/CIR/CodeGen/array.c
@@ -26,7 +26,7 @@ void useFoo(int i) {
 }
 // CHECK: @useFoo
 // CHECK: %[[#V2:]] = cir.get_global @foo : !cir.ptr<!cir.array<!s32i x 0>>
-// CHECK: %[[#V3:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[#V3:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[#V4:]] = cir.cast(array_to_ptrdecay, %[[#V2]] : !cir.ptr<!cir.array<!s32i x 0>>), !cir.ptr<!s32i>
 // CHECK: %[[#V5:]] = cir.ptr_stride(%[[#V4]] : !cir.ptr<!s32i>, %[[#V3]] : !s32i), !cir.ptr<!s32i>
 // CHECK: cir.store{{.*}} %{{.+}}, %[[#V5]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/array.cpp b/clang/test/CIR/CodeGen/array.cpp
index 063ed7c72e96..8a093dde5ab0 100644
--- a/clang/test/CIR/CodeGen/array.cpp
+++ b/clang/test/CIR/CodeGen/array.cpp
@@ -33,7 +33,7 @@ int *a2() {
 // CHECK-NEXT:   %3 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s32i x 4>>), !cir.ptr<!s32i>
 // CHECK-NEXT:   %4 = cir.ptr_stride(%3 : !cir.ptr<!s32i>, %2 : !s32i), !cir.ptr<!s32i>
 // CHECK-NEXT:   cir.store{{.*}} %4, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK-NEXT:   %5 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK-NEXT:   %5 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK-NEXT:   cir.return %5 : !cir.ptr<!s32i>
 
 void local_stringlit() {
@@ -54,11 +54,11 @@ int multidim(int i, int j) {
 
 // CHECK: %3 = cir.alloca !cir.array<!cir.array<!s32i x 2> x 2>, !cir.ptr<!cir.array<!cir.array<!s32i x 2> x 2>>
 // Stride first dimension (stride = 2)
-// CHECK: %4 = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %4 = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %5 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!cir.array<!s32i x 2> x 2>>), !cir.ptr<!cir.array<!s32i x 2>>
 // CHECK: %6 = cir.ptr_stride(%5 : !cir.ptr<!cir.array<!s32i x 2>>, %4 : !s32i), !cir.ptr<!cir.array<!s32i x 2>>
 // Stride second dimension (stride = 1)
-// CHECK: %7 = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %7 = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %8 = cir.cast(array_to_ptrdecay, %6 : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!s32i>
 // CHECK: %9 = cir.ptr_stride(%8 : !cir.ptr<!s32i>, %7 : !s32i), !cir.ptr<!s32i>
 
@@ -75,7 +75,7 @@ struct S {
 void testPointerDecaySubscriptAccess(int arr[]) {
 // CHECK: cir.func @{{.+}}testPointerDecaySubscriptAccess
   arr[1];
-  // CHECK: %[[#BASE:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+  // CHECK: %[[#BASE:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
   // CHECK: %[[#DIM1:]] = cir.const #cir.int<1> : !s32i
   // CHECK: cir.ptr_stride(%[[#BASE]] : !cir.ptr<!s32i>, %[[#DIM1]] : !s32i), !cir.ptr<!s32i>
 }
@@ -83,7 +83,7 @@ void testPointerDecaySubscriptAccess(int arr[]) {
 void testPointerDecayedArrayMultiDimSubscriptAccess(int arr[][3]) {
 // CHECK: cir.func @{{.+}}testPointerDecayedArrayMultiDimSubscriptAccess
   arr[1][2];
-  // CHECK: %[[#V1:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 3>>>, !cir.ptr<!cir.array<!s32i x 3>>
+  // CHECK: %[[#V1:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 3>>>, !cir.ptr<!cir.array<!s32i x 3>>
   // CHECK: %[[#V2:]] = cir.const #cir.int<1> : !s32i
   // CHECK: %[[#V3:]] = cir.ptr_stride(%[[#V1]] : !cir.ptr<!cir.array<!s32i x 3>>, %[[#V2]] : !s32i), !cir.ptr<!cir.array<!s32i x 3>>
   // CHECK: %[[#V4:]] = cir.const #cir.int<2> : !s32i
diff --git a/clang/test/CIR/CodeGen/asm.c b/clang/test/CIR/CodeGen/asm.c
index 0e354dc1a489..8b5d03c7c754 100644
--- a/clang/test/CIR/CodeGen/asm.c
+++ b/clang/test/CIR/CodeGen/asm.c
@@ -57,7 +57,7 @@ void empty6(int x) {
 }
 
 // CHECK: [[TMP0:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] 
-// CHECK: [[TMP1:%.*]] = cir.load %0 : !cir.ptr<!u32i>, !u32i
+// CHECK: [[TMP1:%.*]] = cir.load{{.*}} %0 : !cir.ptr<!u32i>, !u32i
 // CHECK: [[TMP2:%.*]] = cir.asm(x86_att, 
 // CHECK:       out = [],
 // CHECK:       in = [%3 : !u32i],
@@ -76,7 +76,7 @@ unsigned add1(unsigned int x) {
 
 // CHECK: [[TMP0:%.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] {alignment = 4 : i64}
 // CHECK: cir.store{{.*}} %arg0, [[TMP0]] : !u32i, !cir.ptr<!u32i>
-// CHECK: [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!u32i>, !u32i
+// CHECK: [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!u32i>, !u32i
 // CHECK: [[TMP2:%.*]] = cir.asm(x86_att, 
 // CHECK:       out = [],
 // CHECK:       in = [],
@@ -92,7 +92,7 @@ unsigned add2(unsigned int x) {
 
 
 // CHECK: [[TMP0:%.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init]
-// CHECK: [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!u32i>, !u32i
+// CHECK: [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!u32i>, !u32i
 // CHECK: [[TMP2:%.*]] = cir.asm(x86_att, 
 // CHECK:       out = [],
 // CHECK:       in = [],
@@ -110,7 +110,7 @@ unsigned add3(unsigned int x) { // ((42 + x) - 1) * 2
 
 // CHECK: [[TMP0:%.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["x", init] 
 // CHECK: cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: [[TMP1:%.*]] = cir.load deref [[TMP0]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: [[TMP1:%.*]] = cir.load deref{{.*}}  [[TMP0]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK: cir.asm(x86_att, 
 // CHECK:       out = [%1 : !cir.ptr<!s32i> (maybe_memory)],
 // CHECK:       in = [],
@@ -127,8 +127,8 @@ void add4(int *x) {
 // CHECK: [[TMP2:%.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["r"]
 // CHECK: cir.store{{.*}} %arg0, [[TMP0]] : !cir.float, !cir.ptr<!cir.float>
 // CHECK: cir.store{{.*}} %arg1, [[TMP1]] : !cir.float, !cir.ptr<!cir.float>
-// CHECK: [[TMP3:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.float>, !cir.float
-// CHECK: [[TMP4:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.float>, !cir.float
+// CHECK: [[TMP3:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.float>, !cir.float
+// CHECK: [[TMP4:%.*]] = cir.load{{.*}} [[TMP1]] : !cir.ptr<!cir.float>, !cir.float
 // CHECK: [[TMP5:%.*]] = cir.asm(x86_att, 
 // CHECK:       out = [],
 // CHECK:       in = [%4 : !cir.float, %5 : !cir.float],
diff --git a/clang/test/CIR/CodeGen/assign-operator.cpp b/clang/test/CIR/CodeGen/assign-operator.cpp
index dfa1de938ace..1bf6fc784984 100644
--- a/clang/test/CIR/CodeGen/assign-operator.cpp
+++ b/clang/test/CIR/CodeGen/assign-operator.cpp
@@ -16,7 +16,7 @@ struct String {
   // CHECK:   %1 = cir.alloca !cir.ptr<!rec_String>, !cir.ptr<!cir.ptr<!rec_String>>, ["s", init, const] {alignment = 8 : i64}
   // CHECK:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_StringView>
   // CHECK:   cir.store{{.*}} %arg1, %1 : !cir.ptr<!rec_String>
-  // CHECK:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_StringView>>
+  // CHECK:   %2 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_StringView>>
 
   // Get address of `this->size`
 
@@ -24,7 +24,7 @@ struct String {
 
   // Get address of `s`
 
-  // CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!rec_String>>
+  // CHECK:   %4 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!rec_String>>
 
   // Get the address of s.size
 
@@ -32,7 +32,7 @@ struct String {
 
   // Load value from s.size and store in this->size
 
-  // CHECK:   %6 = cir.load %5 : !cir.ptr<!s64i>, !s64i
+  // CHECK:   %6 = cir.load{{.*}} %5 : !cir.ptr<!s64i>, !s64i
   // CHECK:   cir.store{{.*}} %6, %3 : !s64i, !cir.ptr<!s64i>
   // CHECK:   cir.return
   // CHECK: }
@@ -45,14 +45,14 @@ struct String {
   // CHECK:   %2 = cir.alloca !cir.ptr<!rec_StringView>, !cir.ptr<!cir.ptr<!rec_StringView>>, ["__retval"] {alignment = 8 : i64}
   // CHECK:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_StringView>
   // CHECK:   cir.store{{.*}} %arg1, %1 : !cir.ptr<!rec_StringView>
-  // CHECK:   %3 = cir.load deref %0 : !cir.ptr<!cir.ptr<!rec_StringView>>
-  // CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!rec_StringView>>
+  // CHECK:   %3 = cir.load{{.*}} deref %0 : !cir.ptr<!cir.ptr<!rec_StringView>>
+  // CHECK:   %4 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!rec_StringView>>
   // CHECK:   %5 = cir.get_member %4[0] {name = "size"}
-  // CHECK:   %6 = cir.load %5 : !cir.ptr<!s64i>, !s64i
+  // CHECK:   %6 = cir.load{{.*}} %5 : !cir.ptr<!s64i>, !s64i
   // CHECK:   %7 = cir.get_member %3[0] {name = "size"}
   // CHECK:   cir.store{{.*}} %6, %7 : !s64i, !cir.ptr<!s64i>
   // CHECK:   cir.store{{.*}} %3, %2 : !cir.ptr<!rec_StringView>
-  // CHECK:   %8 = cir.load %2 : !cir.ptr<!cir.ptr<!rec_StringView>>
+  // CHECK:   %8 = cir.load{{.*}} %2 : !cir.ptr<!cir.ptr<!rec_StringView>>
   // CHECK:   cir.return %8 : !cir.ptr<!rec_StringView>
   // CHECK: }
 };
@@ -87,7 +87,7 @@ int main() {
 // CHECK:         %7 = cir.call @_ZN10StringViewaSEOS_(%1, %6) : (!cir.ptr<!rec_StringView>, !cir.ptr<!rec_StringView>) -> !cir.ptr<!rec_StringView>
 // CHECK:       }
 // CHECK:     }
-// CHECK:     %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK:     cir.return %2 : !s32i
 // CHECK: }
 
@@ -113,35 +113,35 @@ struct ContainsNonTrivial {
 // CHECK-NEXT:    %[[#RETVAL:]] = cir.alloca !cir.ptr<!rec_ContainsNonTrivial>
 // CHECK-NEXT:    cir.store{{.*}} %arg0, %[[#THIS]]
 // CHECK-NEXT:    cir.store{{.*}} %arg1, %[[#OTHER]]
-// CHECK-NEXT:    %[[#THIS_LOAD:]] = cir.load deref %[[#THIS]]
+// CHECK-NEXT:    %[[#THIS_LOAD:]] = cir.load{{.*}} deref %[[#THIS]]
 // CHECK-NEXT:    %[[#THIS_START:]] = cir.get_member %[[#THIS_LOAD]][0] {name = "start"}
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CHECK-NEXT:    %[[#OTHER_START:]] = cir.get_member %[[#OTHER_LOAD]][0] {name = "start"}
 // CHECK-NEXT:    cir.call @_ZN21HasNonTrivialAssignOpaSERKS_(%[[#THIS_START]], %[[#OTHER_START]])
 // CHECK-NEXT:    %[[#THIS_I:]] = cir.get_member %[[#THIS_LOAD]][2] {name = "i"}
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CHECK-NEXT:    %[[#OTHER_I:]] = cir.get_member %[[#OTHER_LOAD]][2] {name = "i"}
 // CHECK-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<12> : !u64i
 // CHECK-NEXT:    %[[#THIS_I_CAST:]] = cir.cast(bitcast, %[[#THIS_I]] : !cir.ptr<!s32i>), !cir.ptr<!void>
 // CHECK-NEXT:    %[[#OTHER_I_CAST:]] = cir.cast(bitcast, %[[#OTHER_I]] : !cir.ptr<!s32i>), !cir.ptr<!void>
 // CHECK-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_I_CAST]] to %[[#THIS_I_CAST]]
 // CHECK-NEXT:    %[[#THIS_MIDDLE:]] = cir.get_member %[[#THIS_LOAD]][4] {name = "middle"}
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CHECK-NEXT:    %[[#OTHER_MIDDLE:]] = cir.get_member %[[#OTHER_LOAD]][4] {name = "middle"}
 // CHECK-NEXT:    cir.call @_ZN21HasNonTrivialAssignOpaSERKS_(%[[#THIS_MIDDLE]], %[[#OTHER_MIDDLE]])
 // CHECK-NEXT:    %[[#THIS_K:]] = cir.get_member %[[#THIS_LOAD]][5] {name = "k"}
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CHECK-NEXT:    %[[#OTHER_K:]] = cir.get_member %[[#OTHER_LOAD]][5] {name = "k"}
 // CHECK-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<2> : !u64i
 // CHECK-NEXT:    %[[#THIS_K_CAST:]] = cir.cast(bitcast, %[[#THIS_K]] : !cir.ptr<!u16i>), !cir.ptr<!void>
 // CHECK-NEXT:    %[[#OTHER_K_CAST:]] = cir.cast(bitcast, %[[#OTHER_K]] : !cir.ptr<!u16i>), !cir.ptr<!void>
 // CHECK-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_K_CAST]] to %[[#THIS_K_CAST]]
 // CHECK-NEXT:    %[[#THIS_END:]] = cir.get_member %[[#THIS_LOAD]][6] {name = "end"}
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CHECK-NEXT:    %[[#OTHER_END:]] = cir.get_member %[[#OTHER_LOAD]][6] {name = "end"}
 // CHECK-NEXT:    cir.call @_ZN21HasNonTrivialAssignOpaSERKS_(%[[#THIS_END]], %[[#OTHER_END]])
 // CHECK-NEXT:    cir.store{{.*}} %[[#THIS_LOAD]], %[[#RETVAL]]
-// CHECK-NEXT:    %[[#RETVAL_LOAD:]] = cir.load %[[#RETVAL]]
+// CHECK-NEXT:    %[[#RETVAL_LOAD:]] = cir.load{{.*}} %[[#RETVAL]]
 // CHECK-NEXT:    cir.return %[[#RETVAL_LOAD]]
 // CHECK-NEXT:  }
 ContainsNonTrivial &
@@ -160,9 +160,9 @@ struct Trivial {
 // CHECK-NEXT:    %[[#RETVAL:]] = cir.alloca !cir.ptr<!rec_Trivial>
 // CHECK-NEXT:    cir.store{{.*}} %arg0, %[[#THIS]]
 // CHECK-NEXT:    cir.store{{.*}} %arg1, %[[#OTHER]]
-// CHECK-NEXT:    %[[#THIS_LOAD:]] = cir.load deref %[[#THIS]]
+// CHECK-NEXT:    %[[#THIS_LOAD:]] = cir.load{{.*}} deref %[[#THIS]]
 // CHECK-NEXT:    %[[#THIS_I:]] = cir.get_member %[[#THIS_LOAD]][0] {name = "i"}
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CHECK-NEXT:    %[[#OTHER_I:]] = cir.get_member %[[#OTHER_LOAD]][0] {name = "i"}
 // Note that tail padding bytes are not included.
 // CHECK-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<36> : !u64i
@@ -170,7 +170,7 @@ struct Trivial {
 // CHECK-NEXT:    %[[#OTHER_I_CAST:]] = cir.cast(bitcast, %[[#OTHER_I]] : !cir.ptr<!s32i>), !cir.ptr<!void>
 // CHECK-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_I_CAST]] to %[[#THIS_I_CAST]]
 // CHECK-NEXT:    cir.store{{.*}} %[[#THIS_LOAD]], %[[#RETVAL]]
-// CHECK-NEXT:    %[[#RETVAL_LOAD:]] = cir.load %[[#RETVAL]]
+// CHECK-NEXT:    %[[#RETVAL_LOAD:]] = cir.load{{.*}} %[[#RETVAL]]
 // CHECK-NEXT:    cir.return %[[#RETVAL_LOAD]]
 // CHECK-NEXT:  }
 
@@ -200,10 +200,10 @@ struct ContainsTrivialArray {
 
 // We should be calling operator= here but don't currently.
 // CHECK-LABEL: cir.func @_ZN20ContainsTrivialArrayaSERKS_(
-// CHECK:         %[[#THIS_LOAD:]] = cir.load deref %[[#]]
+// CHECK:         %[[#THIS_LOAD:]] = cir.load{{.*}} deref %[[#]]
 // CHECK-NEXT:    %[[#THIS_ARR:]] = cir.get_member %[[#THIS_LOAD]][0] {name = "arr"}
 // CHECK-NEXT:    %[[#THIS_ARR_CAST:]] = cir.cast(bitcast, %[[#THIS_ARR]] : !cir.ptr<!cir.array<!rec_Trivial x 2>>), !cir.ptr<!void>
-// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#]]
+// CHECK-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#]]
 // CHECK-NEXT:    %[[#OTHER_ARR:]] = cir.get_member %[[#OTHER_LOAD]][0] {name = "arr"}
 // CHECK-NEXT:    %[[#OTHER_ARR_CAST:]] = cir.cast(bitcast, %[[#OTHER_ARR]] : !cir.ptr<!cir.array<!rec_Trivial x 2>>), !cir.ptr<!void>
 // CHECK-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<80> : !u64i
diff --git a/clang/test/CIR/CodeGen/atomic-runtime.cpp b/clang/test/CIR/CodeGen/atomic-runtime.cpp
index 5e872f38c10f..2e5e4cd15df8 100644
--- a/clang/test/CIR/CodeGen/atomic-runtime.cpp
+++ b/clang/test/CIR/CodeGen/atomic-runtime.cpp
@@ -14,21 +14,21 @@ int runtime_load(int *ptr, int order) {
   return __atomic_load_n(ptr, order);
 }
 
-// CHECK: %[[ptr:.*]] = cir.load %[[ptr_var:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[order:.*]] = cir.load %[[order_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[ptr:.*]] = cir.load{{.*}} %[[ptr_var:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[order:.*]] = cir.load{{.*}} %[[order_var:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.switch (%[[order]] : !s32i) {
 // CHECK: cir.case(default, []) {
-// CHECK:   %[[T8:.*]] = cir.load atomic(relaxed) %[[ptr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T8:.*]] = cir.load{{.*}} atomic(relaxed) %[[ptr]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} %[[T8]], %[[temp_var:.*]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:   %[[T8:.*]] = cir.load atomic(acquire) %[[ptr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T8:.*]] = cir.load{{.*}} atomic(acquire) %[[ptr]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} %[[T8]], %[[temp_var]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:   %[[T8:.*]] = cir.load atomic(seq_cst) %[[ptr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T8:.*]] = cir.load{{.*}} atomic(seq_cst) %[[ptr]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} %[[T8]], %[[temp_var]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
@@ -38,23 +38,23 @@ void atomic_store_n(int* ptr, int val, int order) {
   __atomic_store_n(ptr, val, order);
 }
 
-// CHECK: %[[ptr:.*]] = cir.load %[[ptr_var:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[order:.*]] = cir.load %[[order_var:.*]] : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[val:.*]] = cir.load %[[val_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[ptr:.*]] = cir.load{{.*}} %[[ptr_var:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[order:.*]] = cir.load{{.*}} %[[order_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[val:.*]] = cir.load{{.*}} %[[val_var:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} %[[val]], %[[temp_var:.*]] : !s32i, !cir.ptr<!s32i>
 // CHECK: cir.switch (%[[order]] : !s32i) {
 // CHECK: cir.case(default, []) {
-// CHECK:   %[[T7:.*]] = cir.load %[[temp_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T7:.*]] = cir.load{{.*}} %[[temp_var:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} atomic(relaxed) %[[T7]], %[[ptr]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(equal, [#cir.int<3> : !s32i]) {
-// CHECK:   %[[T7:.*]] = cir.load %[[temp_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T7:.*]] = cir.load{{.*}} %[[temp_var:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} atomic(release) %[[T7]], %[[ptr]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:   %[[T7:.*]] = cir.load %[[temp_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T7:.*]] = cir.load{{.*}} %[[temp_var:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} atomic(seq_cst) %[[T7]], %[[ptr]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
@@ -64,37 +64,37 @@ int atomic_exchange_n(int* ptr, int val, int order) {
   return __atomic_exchange_n(ptr, val, order);
 }
 
-// CHECK: %[[ptr:.*]] = cir.load %[[ptr_var:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[order:.*]] = cir.load %[[order_var:.*]] : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[val:.*]] = cir.load %[[val_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[ptr:.*]] = cir.load{{.*}} %[[ptr_var:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[order:.*]] = cir.load{{.*}} %[[order_var:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[val:.*]] = cir.load{{.*}} %[[val_var:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} %[[val]], %[[temp_var:.*]] : !s32i, !cir.ptr<!s32i>
 // CHECK: cir.switch (%[[order]] : !s32i) {
 // CHECK: cir.case(default, []) {
-// CHECK:   %[[T11:.*]] = cir.load %[[temp_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T11:.*]] = cir.load{{.*}} %[[temp_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[T12:.*]] = cir.atomic.xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[T11]] : !s32i, relaxed) : !s32i
 // CHECK:   cir.store{{.*}} %[[T12]], %[[result:.*]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:   %[[T11:.*]] = cir.load %[[temp_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T11:.*]] = cir.load{{.*}} %[[temp_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[T12:.*]] = cir.atomic.xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[T11]] : !s32i, acquire) : !s32i
 // CHECK:   cir.store{{.*}} %[[T12]], %[[result]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(equal, [#cir.int<3> : !s32i]) {
-// CHECK:   %[[T11:.*]] = cir.load %[[temp_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T11:.*]] = cir.load{{.*}} %[[temp_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[T12:.*]] = cir.atomic.xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[T11]] : !s32i, release) : !s32i
 // CHECK:   cir.store{{.*}} %[[T12]], %[[result]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(equal, [#cir.int<4> : !s32i]) {
-// CHECK:   %[[T11:.*]] = cir.load %[[temp_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T11:.*]] = cir.load{{.*}} %[[temp_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[T12:.*]] = cir.atomic.xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[T11]] : !s32i, acq_rel) : !s32i
 // CHECK:   cir.store{{.*}} %[[T12]], %[[result]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
 // CHECK: }
 // CHECK: cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:   %[[T11:.*]] = cir.load %[[temp_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[T11:.*]] = cir.load{{.*}} %[[temp_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[T12:.*]] = cir.atomic.xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[T11]] : !s32i, seq_cst) : !s32i
 // CHECK:   cir.store{{.*}} %[[T12]], %[[result]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.break
@@ -107,19 +107,19 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
                                      success, failure);
 }
 
-// CHECK: %[[ptr:.*]] = cir.load %[[T0:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[success:.*]] = cir.load %[[T3:.*]] : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[expected_addr:.*]] = cir.load %[[T1:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[T11:.*]] = cir.load %[[T2:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[ptr:.*]] = cir.load{{.*}} %[[T0:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[success:.*]] = cir.load{{.*}} %[[T3:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[expected_addr:.*]] = cir.load{{.*}} %[[T1:.*]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[T11:.*]] = cir.load{{.*}} %[[T2:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} %[[T11]], %[[desired_var:.*]] : !s32i, !cir.ptr<!s32i>
-// CHECK: %[[failure:.*]] = cir.load %[[T4:.*]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[failure:.*]] = cir.load{{.*}} %[[T4:.*]] : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[T13:.*]] = cir.const #false
 // CHECK: cir.switch (%[[success]] : !s32i) {
 // CHECK: cir.case(default, []) {
 // CHECK:   cir.switch (%[[failure]] : !s32i) {
 // CHECK:   cir.case(default, []) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = relaxed, failure = relaxed) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -129,8 +129,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = relaxed, failure = acquire) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -140,8 +140,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = relaxed, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -156,8 +156,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK: cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
 // CHECK:   cir.switch (%[[failure]] : !s32i) {
 // CHECK:   cir.case(default, []) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = acquire, failure = relaxed) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -167,8 +167,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = acquire, failure = acquire) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -178,8 +178,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = acquire, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -194,8 +194,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK: cir.case(equal, [#cir.int<3> : !s32i])
 // CHECK:   cir.switch (%[[failure]] : !s32i) {
 // CHECK:   cir.case(default, []) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = release, failure = relaxed) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -205,8 +205,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = release, failure = acquire) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -216,8 +216,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = release, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -232,8 +232,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK: cir.case(equal, [#cir.int<4> : !s32i]) {
 // CHECK:   cir.switch (%[[failure]] : !s32i) {
 // CHECK:   cir.case(default, []) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = acq_rel, failure = relaxed) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -243,8 +243,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = acq_rel, failure = acquire) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -254,8 +254,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = acq_rel, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -270,8 +270,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK: cir.case(equal, [#cir.int<5> : !s32i]) {
 // CHECK:   cir.switch (%[[failure]] : !s32i) {
 // CHECK:   cir.case(default, []) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = seq_cst, failure = relaxed) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -281,8 +281,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(anyof, [#cir.int<1> : !s32i, #cir.int<2> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = seq_cst, failure = acquire) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
@@ -292,8 +292,8 @@ bool atomic_compare_exchange_n(int* ptr, int* expected,
 // CHECK:     cir.break
 // CHECK:   }
 // CHECK:   cir.case(equal, [#cir.int<5> : !s32i]) {
-// CHECK:     %[[expected:.*]] = cir.load %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
-// CHECK:     %[[desired:.*]] = cir.load %[[desired_var]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[expected:.*]] = cir.load{{.*}} %[[expected_addr]] : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[desired:.*]] = cir.load{{.*}} %[[desired_var]] : !cir.ptr<!s32i>, !s32i
 // CHECK:     %old, %cmp = cir.atomic.cmp_xchg(%[[ptr]] : !cir.ptr<!s32i>, %[[expected]] : !s32i, %[[desired]] : !s32i, success = seq_cst, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK:     %[[succeeded:.*]] = cir.unary(not, %cmp) : !cir.bool, !cir.bool
 // CHECK:     cir.if %[[succeeded]] {
diff --git a/clang/test/CIR/CodeGen/atomic-thread-fence.c b/clang/test/CIR/CodeGen/atomic-thread-fence.c
index 4648005838d1..fe9025a7ce8f 100644
--- a/clang/test/CIR/CodeGen/atomic-thread-fence.c
+++ b/clang/test/CIR/CodeGen/atomic-thread-fence.c
@@ -42,7 +42,7 @@ void modifyWithThreadFence(DataPtr d) {
 // CIR:    %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
 // CIR:    cir.atomic.fence syncscope(system) seq_cst
 // CIR:    %[[VAL_42:.*]] = cir.const #cir.int<42> : !s32i
-// CIR:    %[[LOAD_DATA:.*]] = cir.load %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
+// CIR:    %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
 // CIR:    %[[DATA_VALUE:.*]] = cir.get_member %[[LOAD_DATA]][0] {name = "value"} : !cir.ptr<!rec_Data> -> !cir.ptr<!s32i>
 // CIR:    cir.store{{.*}} %[[VAL_42]], %[[DATA_VALUE]] : !s32i, !cir.ptr<!s32i>
 // CIR:    cir.return
@@ -63,7 +63,7 @@ void modifyWithSignalFence(DataPtr d) {
 // CIR:    %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
 // CIR:    cir.atomic.fence syncscope(single_thread) seq_cst
 // CIR:    %[[VAL_42:.*]] = cir.const #cir.int<24> : !s32i
-// CIR:    %[[LOAD_DATA:.*]] = cir.load %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
+// CIR:    %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
 // CIR:    %[[DATA_VALUE:.*]] = cir.get_member %[[LOAD_DATA]][0] {name = "value"} : !cir.ptr<!rec_Data> -> !cir.ptr<!s32i>
 // CIR:    cir.store{{.*}} %[[VAL_42]], %[[DATA_VALUE]] : !s32i, !cir.ptr<!s32i>
 // CIR:    cir.return
@@ -84,14 +84,14 @@ void loadWithThreadFence(DataPtr d) {
 // CIR:    %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
 // CIR:    %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["atomic-temp"] {alignment = 8 : i64}
 // CIR:    cir.atomic.fence syncscope(system) seq_cst
-// CIR:    %[[LOAD_DATA:.*]] = cir.load %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
+// CIR:    %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
 // CIR:    %[[DATA_VALUE:.*]] = cir.get_member %[[LOAD_DATA]][1] {name = "ptr"} : !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!void>>
 // CIR:    %[[CASTED_DATA_VALUE:.*]] = cir.cast(bitcast, %[[DATA_VALUE]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!u64i>
 // CIR:    %[[CASTED_ATOMIC_TEMP:.*]] = cir.cast(bitcast, %[[ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!u64i>
-// CIR:    %[[ATOMIC_LOAD:.*]] = cir.load atomic(seq_cst) %[[CASTED_DATA_VALUE]] : !cir.ptr<!u64i>, !u64i
+// CIR:    %[[ATOMIC_LOAD:.*]] = cir.load{{.*}} atomic(seq_cst) %[[CASTED_DATA_VALUE]] : !cir.ptr<!u64i>, !u64i
 // CIR:    cir.store{{.*}} %[[ATOMIC_LOAD]], %[[CASTED_ATOMIC_TEMP]] : !u64i, !cir.ptr<!u64i>
 // CIR:    %[[DOUBLE_CASTED_ATOMIC_TEMP:.*]] = cir.cast(bitcast, %[[CASTED_ATOMIC_TEMP]] : !cir.ptr<!u64i>), !cir.ptr<!cir.ptr<!void>>
-// CIR:    %[[ATOMIC_LOAD_PTR:.*]] = cir.load %[[DOUBLE_CASTED_ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR:    %[[ATOMIC_LOAD_PTR:.*]] = cir.load{{.*}} %[[DOUBLE_CASTED_ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR:    cir.return
 
 // LLVM-LABEL: @loadWithThreadFence
@@ -113,14 +113,14 @@ void loadWithSignalFence(DataPtr d) {
 // CIR:    %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
 // CIR:    %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["atomic-temp"] {alignment = 8 : i64}
 // CIR:    cir.atomic.fence syncscope(single_thread) seq_cst
-// CIR:    %[[LOAD_DATA:.*]] = cir.load %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
+// CIR:    %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
 // CIR:    %[[DATA_PTR:.*]] = cir.get_member %[[LOAD_DATA]][1] {name = "ptr"} : !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!void>>
 // CIR:    %[[CASTED_DATA_PTR:.*]] = cir.cast(bitcast, %[[DATA_PTR]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!u64i>
 // CIR:    %[[CASTED_ATOMIC_TEMP:.*]] = cir.cast(bitcast, %[[ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!u64i>
-// CIR:    %[[ATOMIC_LOAD:.*]] = cir.load atomic(seq_cst) %[[CASTED_DATA_PTR]] : !cir.ptr<!u64i>, !u64i
+// CIR:    %[[ATOMIC_LOAD:.*]] = cir.load{{.*}} atomic(seq_cst) %[[CASTED_DATA_PTR]] : !cir.ptr<!u64i>, !u64i
 // CIR:    cir.store{{.*}} %[[ATOMIC_LOAD]], %[[CASTED_ATOMIC_TEMP]] : !u64i, !cir.ptr<!u64i>
 // CIR:    %[[DOUBLE_CASTED_ATOMIC_TEMP:.*]] = cir.cast(bitcast, %[[CASTED_ATOMIC_TEMP]] : !cir.ptr<!u64i>), !cir.ptr<!cir.ptr<!void>>
-// CIR:    %[[LOAD_ATOMIC_TEMP:.*]] = cir.load %[[DOUBLE_CASTED_ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR:    %[[LOAD_ATOMIC_TEMP:.*]] = cir.load{{.*}} %[[DOUBLE_CASTED_ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR:    cir.return
 
 // LLVM-LABEL: @loadWithSignalFence
diff --git a/clang/test/CIR/CodeGen/atomic-xchg-field.c b/clang/test/CIR/CodeGen/atomic-xchg-field.c
index 8e828ea0eb2e..83a933095aec 100644
--- a/clang/test/CIR/CodeGen/atomic-xchg-field.c
+++ b/clang/test/CIR/CodeGen/atomic-xchg-field.c
@@ -25,7 +25,7 @@ void field_access(wPtr item) {
 // CHECK: ![[W:.*]] = !cir.record<struct "w"
 // CHECK-LABEL: @field_access
 // CHECK-NEXT: %[[WADDR:.*]] = cir.alloca !cir.ptr<![[W]]>, {{.*}} {alignment = 8 : i64}
-// CHECK: %[[FIELD:.*]] = cir.load %[[WADDR]]
+// CHECK: %[[FIELD:.*]] = cir.load{{.*}} %[[WADDR]]
 // CHECK: %[[MEMBER:.*]] = cir.get_member %[[FIELD]][1] {name = "ref"}
 // CHECK: %[[CASTED_MEMBER:.*]] = cir.cast(bitcast, %[[MEMBER]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!u64i>
 // CHECK: cir.atomic.xchg(%[[CASTED_MEMBER]] : !cir.ptr<!u64i>, {{.*}} : !u64i, seq_cst)
@@ -79,7 +79,7 @@ void structLoad(unsigned referenceCount, wPtr item) {
 // CHECK-LABEL: @structLoad
 // CHECK:    %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["atomic-temp"]
 // CHECK:    %[[RES:.*]] = cir.cast(bitcast, %[[ATOMIC_TEMP]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!u64i>
-// CHECK:    %[[ATOMIC_LOAD:.*]] = cir.load atomic(seq_cst) %6 : !cir.ptr<!u64i>, !u64i
+// CHECK:    %[[ATOMIC_LOAD:.*]] = cir.load{{.*}} atomic(seq_cst) %6 : !cir.ptr<!u64i>, !u64i
 // CHECK:    cir.store{{.*}} %[[ATOMIC_LOAD]], %[[RES]] : !u64i, !cir.ptr<!u64i>
 
 // No LLVM tests needed for this one, already covered elsewhere.
diff --git a/clang/test/CIR/CodeGen/atomic.cpp b/clang/test/CIR/CodeGen/atomic.cpp
index 6de8c2e2879a..10ff51f70a9c 100644
--- a/clang/test/CIR/CodeGen/atomic.cpp
+++ b/clang/test/CIR/CodeGen/atomic.cpp
@@ -31,10 +31,10 @@ int basic_binop_fetch(int *i) {
 // CHECK:  %[[ARGI:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["i", init] {alignment = 8 : i64}
 // CHECK:  %[[ONE_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, [".atomictmp"] {alignment = 4 : i64}
 // CHECK:  cir.store{{.*}} %arg0, %[[ARGI]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK:  %[[I:.*]] = cir.load %[[ARGI]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:  %[[I:.*]] = cir.load{{.*}} %[[ARGI]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:  %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
 // CHECK:  cir.store{{.*}} %[[ONE]], %[[ONE_ADDR]] : !s32i, !cir.ptr<!s32i>
-// CHECK:  %[[VAL:.*]] = cir.load %[[ONE_ADDR]] : !cir.ptr<!s32i>, !s32i
+// CHECK:  %[[VAL:.*]] = cir.load{{.*}} %[[ONE_ADDR]] : !cir.ptr<!s32i>, !s32i
 // CHECK:  cir.atomic.fetch(add, %[[I]] : !cir.ptr<!s32i>, %[[VAL]] : !s32i, seq_cst) : !s32i
 
 // LLVM: define dso_local i32 @_Z17basic_binop_fetchPi
@@ -152,7 +152,7 @@ int fi1(_Atomic(int) *i) {
 }
 
 // CHECK: cir.func @_Z3fi1PU7_Atomici
-// CHECK: cir.load atomic(seq_cst)
+// CHECK: cir.load{{.*}} atomic(seq_cst)
 
 // LLVM-LABEL: @_Z3fi1PU7_Atomici
 // LLVM: load atomic i32, ptr {{.*}} seq_cst, align 4
@@ -164,7 +164,7 @@ int fi1a(int *i) {
 }
 
 // CHECK-LABEL: @_Z4fi1aPi
-// CHECK: cir.load atomic(seq_cst)
+// CHECK: cir.load{{.*}} atomic(seq_cst)
 
 // LLVM-LABEL: @_Z4fi1aPi
 // LLVM: load atomic i32, ptr {{.*}} seq_cst, align 4
@@ -174,7 +174,7 @@ int fi1b(int *i) {
 }
 
 // CHECK-LABEL: @_Z4fi1bPi
-// CHECK: cir.load atomic(seq_cst)
+// CHECK: cir.load{{.*}} atomic(seq_cst)
 
 // LLVM-LABEL: @_Z4fi1bPi
 // LLVM: load atomic i32, ptr {{.*}} seq_cst, align 4
@@ -184,7 +184,7 @@ int fi1c(atomic_int *i) {
 }
 
 // CHECK-LABEL: @_Z4fi1cPU7_Atomici
-// CHECK: cir.load atomic(seq_cst)
+// CHECK: cir.load{{.*}} atomic(seq_cst)
 
 // LLVM-LABEL: @_Z4fi1cPU7_Atomici
 // LLVM: load atomic i32, ptr {{.*}} seq_cst, align 4
@@ -367,8 +367,8 @@ void inc_int(int* a, int b) {
   int c = __sync_fetch_and_add(a, b);
 }
 // CHECK-LABEL: @_Z7inc_int
-// CHECK: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[VAL:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[VAL:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[RES:.*]] = cir.atomic.fetch(add, %[[PTR]] : !cir.ptr<!s32i>, %[[VAL]] : !s32i, seq_cst) fetch_first : !s32i
 // CHECK: cir.store{{.*}} %[[RES]], {{.*}} : !s32i, !cir.ptr<!s32i>
 
@@ -380,8 +380,8 @@ void sub_int(int* a, int b) {
 }
 
 // CHECK-LABEL: _Z7sub_int
-// CHECK: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[VAL:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[VAL:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[RES:.*]] = cir.atomic.fetch(sub, %[[PTR]] : !cir.ptr<!s32i>, %[[VAL]] : !s32i, seq_cst) fetch_first : !s32i
 // CHECK: cir.store{{.*}} %[[RES]], {{.*}} : !s32i, !cir.ptr<!s32i>
 
@@ -448,9 +448,9 @@ void sub_byte(char* a, char b) {
 }
 
 // CHECK-LABEL: @_Z12cmp_bool_int
-// CHECK: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[CMP:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[UPD:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[CMP:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[UPD:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[OLD:.*]], %[[RES:.*]] = cir.atomic.cmp_xchg(%[[PTR]] : !cir.ptr<!s32i>, %[[CMP]] : !s32i, %[[UPD]] : !s32i, success = seq_cst, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK: cir.store{{.*}} %[[RES]], {{.*}} : !cir.bool, !cir.ptr<!cir.bool>
 
@@ -495,9 +495,9 @@ void cmp_bool_byte(char* p, char x, char u) {
 }
 
 // CHECK-LABEL: @_Z11cmp_val_int
-// CHECK: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %[[CMP:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[UPD:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %[[CMP:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[UPD:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[OLD:.*]], %[[RES:.*]] = cir.atomic.cmp_xchg(%[[PTR]] : !cir.ptr<!s32i>, %[[CMP]] : !s32i, %[[UPD]] : !s32i, success = seq_cst, failure = seq_cst) syncscope(system) align(4) : (!s32i, !cir.bool)
 // CHECK: cir.store{{.*}} %[[OLD]], {{.*}} : !s32i, !cir.ptr<!s32i>
 
@@ -595,10 +595,10 @@ void sub_uchar(unsigned char* a, char b) {
 }
 
 // CHECK-LABEL: @_Z13cmp_bool_uint
-// CHECK: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
-// CHECK: %[[CMP:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+// CHECK: %[[CMP:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[CMP_U:.*]] = cir.cast(integral, %[[CMP]] : !s32i), !u32i
-// CHECK: %[[UPD:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[UPD:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[UPD_U:.*]] = cir.cast(integral, %[[UPD]] : !s32i), !u32i
 // CHECK: %[[OLD:.*]], %[[RES:.*]] = cir.atomic.cmp_xchg(%[[PTR]] : !cir.ptr<!u32i>, %[[CMP_U]] :
 // CHECK-SAME: !u32i, %[[UPD_U]] : !u32i, success = seq_cst, failure = seq_cst) syncscope(system) align(4) : (!u32i, !cir.bool)
@@ -635,10 +635,10 @@ void cmp_bool_ulong(unsigned long* p, long x, long u) {
 }
 
 // CHECK-LABEL: @_Z12cmp_val_uint
-// CHECK: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
-// CHECK: %[[CMP:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+// CHECK: %[[CMP:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[CMP_U:.*]] = cir.cast(integral, %[[CMP]] : !s32i), !u32i
-// CHECK: %[[UPD:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[UPD:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[UPD_U:.*]] = cir.cast(integral, %[[UPD]] : !s32i), !u32i
 // CHECK: %[[OLD:.*]], %[[RES:.*]] = cir.atomic.cmp_xchg(%[[PTR]] : !cir.ptr<!u32i>, %[[CMP_U]] :
 // CHECK-SAME: !u32i, %[[UPD_U]] : !u32i, success = seq_cst, failure = seq_cst) syncscope(system) align(4) : (!u32i, !cir.bool)
diff --git a/clang/test/CIR/CodeGen/basic.c b/clang/test/CIR/CodeGen/basic.c
index 5cb2ff1b7db9..9d61b2e05e96 100644
--- a/clang/test/CIR/CodeGen/basic.c
+++ b/clang/test/CIR/CodeGen/basic.c
@@ -15,10 +15,10 @@ int foo(int i) {
 // CIR-NEXT: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
 // CIR-NEXT: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CIR-NEXT: cir.store{{.*}} %arg0, %0 : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT: %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: %3 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.store{{.*}} %3, %1 : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: %4 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.return %4 : !s32i
 
 int f2(void) { return 3; }
@@ -27,7 +27,7 @@ int f2(void) { return 3; }
 // CIR-NEXT: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CIR-NEXT: %1 = cir.const #cir.int<3> : !s32i
 // CIR-NEXT: cir.store{{.*}} %1, %0 : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.return %2 : !s32i
 
 // LLVM: define dso_local i32 @f2()
@@ -48,7 +48,7 @@ int f3(void) {
 // CIR-NEXT: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
 // CIR-NEXT: %2 = cir.const #cir.int<3> : !s32i
 // CIR-NEXT: cir.store{{.*}} %2, %1 : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.store{{.*}} %3, %0 : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: %4 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT: cir.return %4 : !s32i
diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp
index d9bf39b73c66..e93b4050bb39 100644
--- a/clang/test/CIR/CodeGen/basic.cpp
+++ b/clang/test/CIR/CodeGen/basic.cpp
@@ -44,15 +44,15 @@ int *p2() {
 // CHECK-NEXT:    cir.store{{.*}} %8, %7 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:    cir.store{{.*}} %7, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CHECK-NEXT:    %9 = cir.const #cir.int<42> : !s32i
-// CHECK-NEXT:    %10 = cir.load deref %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK-NEXT:    %10 = cir.load deref{{.*}}  %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK-NEXT:    cir.store{{.*}} %9, %10 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:  } loc(#[[locScope:loc[0-9]+]])
 // CHECK-NEXT:  %3 = cir.const #cir.int<42> : !s32i
-// CHECK-NEXT:  %4 = cir.load deref %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK-NEXT:  %4 = cir.load deref{{.*}}  %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK-NEXT:  cir.store{{.*}} %3, %4 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:  %5 = cir.load %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK-NEXT:  %5 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK-NEXT:  cir.store{{.*}} %5, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK-NEXT:  %6 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK-NEXT:  %6 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK-NEXT:  cir.return %6 : !cir.ptr<!s32i>
 
 void b0() { bool x = true, y = false; }
@@ -64,7 +64,7 @@ void b0() { bool x = true, y = false; }
 void b1(int a) { bool b = a; }
 
 // CHECK: cir.func @_Z2b1i(%arg0: !s32i loc({{.*}}))
-// CHECK: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK: %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK: %3 = cir.cast(int_to_bool, %2 : !s32i), !cir.bool
 // CHECK: cir.store{{.*}} %3, %1 : !cir.bool, !cir.ptr<!cir.bool>
 
@@ -79,7 +79,7 @@ void if0(int a) {
 
 // CHECK: cir.func @_Z3if0i(%arg0: !s32i loc({{.*}}))
 // CHECK: cir.scope {
-// CHECK:   %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK:   %3 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK:   %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
 // CHECK-NEXT:   cir.if %4 {
 // CHECK-NEXT:     %5 = cir.const #cir.int<3> : !s32i
@@ -107,13 +107,13 @@ void if1(int a, bool b, bool c) {
 
 // CHECK: cir.func @_Z3if1ibb(%arg0: !s32i loc({{.*}}), %arg1: !cir.bool loc({{.*}}), %arg2: !cir.bool loc({{.*}}))
 // CHECK: cir.scope {
-// CHECK:   %5 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK:   %5 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK:   %6 = cir.cast(int_to_bool, %5 : !s32i), !cir.bool
 // CHECK:   cir.if %6 {
 // CHECK:     %7 = cir.const #cir.int<3> : !s32i
 // CHECK:     cir.store{{.*}} %7, %3 : !s32i, !cir.ptr<!s32i>
 // CHECK:     cir.scope {
-// CHECK:       %8 = cir.load %1 : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:       %8 = cir.load{{.*}} %1 : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK-NEXT:       cir.if %8 {
 // CHECK-NEXT:         %9 = cir.const #cir.int<8> : !s32i
 // CHECK-NEXT:         cir.store{{.*}} %9, %3 : !s32i, !cir.ptr<!s32i>
@@ -121,7 +121,7 @@ void if1(int a, bool b, bool c) {
 // CHECK:     }
 // CHECK:   } else {
 // CHECK:     cir.scope {
-// CHECK:       %8 = cir.load %2 : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:       %8 = cir.load{{.*}} %2 : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK-NEXT:       cir.if %8 {
 // CHECK-NEXT:         %9 = cir.const #cir.int<14> : !s32i
 // CHECK-NEXT:         cir.store{{.*}} %9, %3 : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/bf16-ops.c b/clang/test/CIR/CodeGen/bf16-ops.c
index a94f82b46654..0504f96e721d 100644
--- a/clang/test/CIR/CodeGen/bf16-ops.c
+++ b/clang/test/CIR/CodeGen/bf16-ops.c
@@ -1039,12 +1039,12 @@ void foo(void) {
 
   h0 = h1;
   //      NONATIVE: %[[#A:]] = cir.get_global @h1 : !cir.ptr<!cir.bf16>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#B]], %[[#C]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @h1 : !cir.ptr<!cir.bf16>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#B]], %[[#C]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1073,13 +1073,13 @@ void foo(void) {
 
   h0 = f0;
   //      NONATIVE: %[[#A:]] = cir.get_global @f0 : !cir.ptr<!cir.float>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.float>, !cir.float
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.float>, !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @f0 : !cir.ptr<!cir.float>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.float>, !cir.float
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.float>, !cir.float
   // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
@@ -1094,13 +1094,13 @@ void foo(void) {
 
   h0 = i0;
   //      NONATIVE: %[[#A:]] = cir.get_global @i0 : !cir.ptr<!s32i>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!s32i>, !s32i
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!s32i>, !s32i
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.bf16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @i0 : !cir.ptr<!s32i>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!s32i>, !s32i
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!s32i>, !s32i
   // NATIVE-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.bf16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
@@ -1115,13 +1115,13 @@ void foo(void) {
 
   i0 = h0;
   //      NONATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @i0 : !cir.ptr<!s32i>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !s32i, !cir.ptr<!s32i>
 
   //      NATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @i0 : !cir.ptr<!s32i>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !s32i, !cir.ptr<!s32i>
@@ -1526,13 +1526,13 @@ void foo(void) {
 
   h0 = d0;
   //      NONATIVE: %[[#A:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.double>, !cir.double
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.double>, !cir.double
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.double>, !cir.double
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.double>, !cir.double
   // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
@@ -1547,14 +1547,14 @@ void foo(void) {
 
   h0 = (float)d0;
   //      NONATIVE: %[[#A:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.double>, !cir.double
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.double>, !cir.double
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
   // NONATIVE-NEXT: %[[#E:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %[[#E]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.double>, !cir.double
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.double>, !cir.double
   // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
   // NATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
   // NATIVE-NEXT: %[[#E:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
@@ -1572,13 +1572,13 @@ void foo(void) {
 
   d0 = h0;
   //      NONATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.double
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.double, !cir.ptr<!cir.double>
 
   //      NATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.double
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.double, !cir.ptr<!cir.double>
@@ -1593,14 +1593,14 @@ void foo(void) {
 
   d0 = (float)h0;
   //      NONATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
   // NONATIVE-NEXT: %[[#E:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %[[#E]] : !cir.double, !cir.ptr<!cir.double>
 
   //      NATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
-  // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.load volatile{{.*}}  %[[#A]] : !cir.ptr<!cir.bf16>, !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
   // NATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
   // NATIVE-NEXT: %[[#E:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
@@ -1618,13 +1618,13 @@ void foo(void) {
 
   h0 = s0;
   //      NONATIVE: %[[#A:]] = cir.get_global @s0 : !cir.ptr<!s16i>
-  // NONATIVE-NEXT: %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!s16i>, !s16i
+  // NONATIVE-NEXT: %[[#B:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!s16i>, !s16i
   // NONATIVE-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.bf16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @s0 : !cir.ptr<!s16i>
-  // NATIVE-NEXT: %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!s16i>, !s16i
+  // NATIVE-NEXT: %[[#B:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!s16i>, !s16i
   // NATIVE-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.bf16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.bf16>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %[[#D]] : !cir.bf16, !cir.ptr<!cir.bf16>
diff --git a/clang/test/CIR/CodeGen/binop.cpp b/clang/test/CIR/CodeGen/binop.cpp
index 3f9c44c88d7a..9609458a966d 100644
--- a/clang/test/CIR/CodeGen/binop.cpp
+++ b/clang/test/CIR/CodeGen/binop.cpp
@@ -31,7 +31,7 @@ void b1(bool a, bool b) {
 }
 
 // CHECK: cir.ternary(%3, true
-// CHECK-NEXT: %7 = cir.load %1
+// CHECK-NEXT: %7 = cir.load{{.*}} %1
 // CHECK-NEXT: cir.yield %7
 // CHECK-NEXT: false {
 // CHECK-NEXT: cir.const #false
@@ -41,7 +41,7 @@ void b1(bool a, bool b) {
 // CHECK-NEXT: cir.const #true
 // CHECK-NEXT: cir.yield
 // CHECK-NEXT: false {
-// CHECK-NEXT: %7 = cir.load %1
+// CHECK-NEXT: %7 = cir.load{{.*}} %1
 // CHECK-NEXT: cir.yield
 
 void b2(bool a) {
@@ -55,9 +55,9 @@ void b2(bool a) {
 // CHECK: %1 = cir.alloca {{.*}} ["x", init]
 // CHECK: %2 = cir.const #false
 // CHECK-NEXT: cir.store{{.*}} %2, %1
-// CHECK-NEXT: %3 = cir.load %0
+// CHECK-NEXT: %3 = cir.load{{.*}} %0
 // CHECK-NEXT: cir.store{{.*}} %3, %1
-// CHECK-NEXT: %4 = cir.load %0
+// CHECK-NEXT: %4 = cir.load{{.*}} %0
 // CHECK-NEXT: cir.store{{.*}} %4, %1
 // CHECK-NEXT: %5 = cir.const #true
 // CHECK-NEXT: cir.store{{.*}} %5, %1
@@ -72,12 +72,12 @@ void b3(int a, int b, int c, int d) {
 // CHECK-NEXT: %2 = cir.alloca {{.*}} ["c", init]
 // CHECK-NEXT: %3 = cir.alloca {{.*}} ["d", init]
 // CHECK-NEXT: %4 = cir.alloca {{.*}} ["x", init]
-// CHECK: %5 = cir.load %0
-// CHECK-NEXT: %6 = cir.load %1
+// CHECK: %5 = cir.load{{.*}} %0
+// CHECK-NEXT: %6 = cir.load{{.*}} %1
 // CHECK-NEXT: %7 = cir.cmp(eq, %5, %6)
 // CHECK-NEXT: cir.ternary(%7, true
-// CHECK-NEXT: %13 = cir.load %2
-// CHECK-NEXT: %14 = cir.load %3
+// CHECK-NEXT: %13 = cir.load{{.*}} %2
+// CHECK-NEXT: %14 = cir.load{{.*}} %3
 // CHECK-NEXT: %15 = cir.cmp(eq, %13, %14)
 // CHECK-NEXT: cir.yield %15
 // CHECK-NEXT: }, false {
diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c
index ee1cadea0afe..66a5132d7562 100644
--- a/clang/test/CIR/CodeGen/bitfields.c
+++ b/clang/test/CIR/CodeGen/bitfields.c
@@ -79,7 +79,7 @@ void store_field() {
 
 // CHECK: cir.func {{.*@load_field}}
 // CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init]
-// CHECK:   [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
+// CHECK:   [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
 // CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP1]][1] {name = "d"} : !cir.ptr<!rec_S> -> !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   [[TMP3:%.*]] = cir.get_bitfield(#bfi_d, [[TMP2]] : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 int load_field(S* s) {
@@ -155,7 +155,7 @@ G g = { -123, 254UL};
 // CHECK:   %[[V1:.*]] = cir.get_global @g : !cir.ptr<!rec_anon_struct>
 // CHECK:   %[[V2:.*]] = cir.cast(bitcast, %[[V1]] : !cir.ptr<!rec_anon_struct>), !cir.ptr<!rec_G>
 // CHECK:   %[[V3:.*]] = cir.get_member %[[V2]][1] {name = "y"} : !cir.ptr<!rec_G> -> !cir.ptr<!s32i>
-// CHECK:   cir.load %[[V3]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   cir.load{{.*}} %[[V3]] : !cir.ptr<!s32i>, !s32i
 int get_y() {
   return g.y;
 }
diff --git a/clang/test/CIR/CodeGen/bitfields.cpp b/clang/test/CIR/CodeGen/bitfields.cpp
index 5a6b75dfa90e..4a0a0ce36d07 100644
--- a/clang/test/CIR/CodeGen/bitfields.cpp
+++ b/clang/test/CIR/CodeGen/bitfields.cpp
@@ -44,7 +44,7 @@ void store_field() {
 
 // CHECK: cir.func @_Z10load_field
 // CHECK:   [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init, const]
-// CHECK:   [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
+// CHECK:   [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
 // CHECK:   [[TMP2:%.*]] = cir.get_member [[TMP1]][1] {name = "d"} : !cir.ptr<!rec_S> -> !cir.ptr<!cir.array<!u8i x 3>>
 // CHECK:   [[TMP3:%.*]] = cir.get_bitfield(#bfi_d, [[TMP2]] : !cir.ptr<!cir.array<!u8i x 3>>) -> !s32i
 int load_field(S& s) {
diff --git a/clang/test/CIR/CodeGen/bitint.c b/clang/test/CIR/CodeGen/bitint.c
index 5bf716204e91..a2337f1caebb 100644
--- a/clang/test/CIR/CodeGen/bitint.c
+++ b/clang/test/CIR/CodeGen/bitint.c
@@ -8,15 +8,15 @@ void VLATest(_BitInt(3) A, _BitInt(42) B, _BitInt(17) C) {
 }
 
 //      CHECK: cir.func @VLATest
-//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 3>>, !cir.int<s, 3>
+//      CHECK:   %[[#A:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 3>>, !cir.int<s, 3>
 // CHECK-NEXT:   %[[#A_PROMOTED:]] = cir.cast(integral, %[[#A]] : !cir.int<s, 3>), !u64i
 // CHECK-NEXT:   %[[#SP:]] = cir.stack_save : !cir.ptr<!u8i>
 // CHECK-NEXT:   cir.store{{.*}} %[[#SP]], %{{.+}} : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
 // CHECK-NEXT:   %{{.+}} = cir.alloca !s32i, !cir.ptr<!s32i>, %[[#A_PROMOTED]] : !u64i
-// CHECK-NEXT:   %[[#B:]] = cir.load %1 : !cir.ptr<!cir.int<s, 42>>, !cir.int<s, 42>
+// CHECK-NEXT:   %[[#B:]] = cir.load{{.*}} %1 : !cir.ptr<!cir.int<s, 42>>, !cir.int<s, 42>
 // CHECK-NEXT:   %[[#B_PROMOTED:]] = cir.cast(integral, %[[#B]] : !cir.int<s, 42>), !u64i
 // CHECK-NEXT:   %{{.+}} = cir.alloca !s32i, !cir.ptr<!s32i>, %[[#B_PROMOTED]] : !u64i
-// CHECK-NEXT:   %[[#C:]] = cir.load %2 : !cir.ptr<!cir.int<s, 17>>, !cir.int<s, 17>
+// CHECK-NEXT:   %[[#C:]] = cir.load{{.*}} %2 : !cir.ptr<!cir.int<s, 17>>, !cir.int<s, 17>
 // CHECK-NEXT:   %[[#C_PROMOTED:]] = cir.cast(integral, %[[#C]] : !cir.int<s, 17>), !u64i
 // CHECK-NEXT:   %{{.+}} = cir.alloca !s32i, !cir.ptr<!s32i>, %[[#C_PROMOTED]] : !u64i
 //      CHECK: }
diff --git a/clang/test/CIR/CodeGen/bitint.cpp b/clang/test/CIR/CodeGen/bitint.cpp
index 43cef1fcc15e..3dfcbc1a7237 100644
--- a/clang/test/CIR/CodeGen/bitint.cpp
+++ b/clang/test/CIR/CodeGen/bitint.cpp
@@ -45,8 +45,8 @@ i10 test_arith(i10 lhs, i10 rhs) {
 }
 
 //      CHECK: cir.func @_Z10test_arithDB10_S_(%arg0: !cir.int<s, 10> loc({{.+}}), %arg1: !cir.int<s, 10> loc({{.+}})) -> !cir.int<s, 10>
-//      CHECK:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 10>>, !cir.int<s, 10>
-// CHECK-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 10>>, !cir.int<s, 10>
+//      CHECK:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 10>>, !cir.int<s, 10>
+// CHECK-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 10>>, !cir.int<s, 10>
 // CHECK-NEXT:   %{{.+}} = cir.binop(add, %[[#LHS]], %[[#RHS]]) nsw : !cir.int<s, 10>
 //      CHECK: }
 
@@ -56,7 +56,7 @@ void Size1ExtIntParam(unsigned _BitInt(1) A) {
 }
 
 //      CHECK: cir.func @_Z16Size1ExtIntParamDU1_
-//      CHECK:   %[[#A:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<u, 1>>, !cir.int<u, 1>
+//      CHECK:   %[[#A:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<u, 1>>, !cir.int<u, 1>
 // CHECK-NEXT:   %[[#IDX:]] = cir.const #cir.int<2> : !s32i
 // CHECK-NEXT:   %[[#ARRAY:]] = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!cir.int<u, 1> x 5>>), !cir.ptr<!cir.int<u, 1>>
 // CHECK-NEXT:   %[[#PTR:]] = cir.ptr_stride(%[[#ARRAY]] : !cir.ptr<!cir.int<u, 1>>, %[[#IDX]] : !s32i), !cir.ptr<!cir.int<u, 1>>
diff --git a/clang/test/CIR/CodeGen/bool.c b/clang/test/CIR/CodeGen/bool.c
index eba999b7c806..8d8f8dd1af85 100644
--- a/clang/test/CIR/CodeGen/bool.c
+++ b/clang/test/CIR/CodeGen/bool.c
@@ -20,7 +20,7 @@ void init_bool(void) {
 // CHECK:    cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
 // CHECK:    [[TMP1:%.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:    [[TMP2:%.*]] = cir.cast(int_to_bool, [[TMP1]] : !s32i), !cir.bool
-// CHECK:    [[TMP3:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
+// CHECK:    [[TMP3:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
 // CHECK:    [[TMP4:%.*]] = cir.get_member [[TMP3]][0] {name = "x"} : !cir.ptr<!rec_S> -> !cir.ptr<!cir.bool>
 // CHECK:    cir.store{{.*}} [[TMP2]], [[TMP4]] : !cir.bool, !cir.ptr<!cir.bool>
 void store_bool(S *s) {
@@ -31,9 +31,9 @@ void store_bool(S *s) {
 // CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init] {alignment = 8 : i64}
 // CHECK:    [[TMP1:%.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
 // CHECK:    cir.store{{.*}} %arg0, [[TMP0]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
-// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
+// CHECK:    [[TMP2:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
 // CHECK:    [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "x"} : !cir.ptr<!rec_S> -> !cir.ptr<!cir.bool>
-// CHECK:    [[TMP4:%.*]] = cir.load [[TMP3]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:    [[TMP4:%.*]] = cir.load{{.*}} [[TMP3]] : !cir.ptr<!cir.bool>, !cir.bool
 void load_bool(S *s) {
   bool x = s->x;
 }
diff --git a/clang/test/CIR/CodeGen/builtin-alloca.c b/clang/test/CIR/CodeGen/builtin-alloca.c
index 3aa6b04bbeb9..8a682a17cb63 100644
--- a/clang/test/CIR/CodeGen/builtin-alloca.c
+++ b/clang/test/CIR/CodeGen/builtin-alloca.c
@@ -11,7 +11,7 @@ void my_alloca(size_t n)
 }
 // CIR:       cir.func @my_alloca([[ALLOCA_SIZE:%.*]]: !u64i
 // CIR:       cir.store [[ALLOCA_SIZE]], [[LOCAL_VAR_ALLOCA_SIZE:%.*]] : !u64i, !cir.ptr<!u64i>
-// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
+// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load{{.*}} [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
 // CIR:       [[ALLOCA_RES:%.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, [[TMP_ALLOCA_SIZE]] : !u64i, ["bi_alloca"] {alignment = 16 : i64}
 // CIR-NEXT:  cir.cast(bitcast, [[ALLOCA_RES]] : !cir.ptr<!u8i>), !cir.ptr<!void>
 // CIR: }
@@ -30,7 +30,7 @@ void my___builtin_alloca(size_t n)
 
 // CIR:       cir.func @my___builtin_alloca([[ALLOCA_SIZE:%.*]]: !u64i
 // CIR:       cir.store [[ALLOCA_SIZE]], [[LOCAL_VAR_ALLOCA_SIZE:%.*]] : !u64i, !cir.ptr<!u64i>
-// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
+// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load{{.*}} [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
 // CIR:       [[ALLOCA_RES:%.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, [[TMP_ALLOCA_SIZE]] : !u64i, ["bi_alloca"] {alignment = 16 : i64}
 // CIR-NEXT:  cir.cast(bitcast, [[ALLOCA_RES]] : !cir.ptr<!u8i>), !cir.ptr<!void>
 // CIR: }
@@ -49,7 +49,7 @@ void my__builtin_alloca_uninitialized(size_t n)
 
 // CIR:       cir.func @my__builtin_alloca_uninitialized([[ALLOCA_SIZE:%.*]]: !u64i
 // CIR:       cir.store [[ALLOCA_SIZE]], [[LOCAL_VAR_ALLOCA_SIZE:%.*]] : !u64i, !cir.ptr<!u64i>
-// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
+// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load{{.*}} [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
 // CIR:       [[ALLOCA_RES:%.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, [[TMP_ALLOCA_SIZE]] : !u64i, ["bi_alloca"] {alignment = 16 : i64}
 // CIR-NEXT:  cir.cast(bitcast, [[ALLOCA_RES]] : !cir.ptr<!u8i>), !cir.ptr<!void>
 // CIR: }
diff --git a/clang/test/CIR/CodeGen/builtin-assume.cpp b/clang/test/CIR/CodeGen/builtin-assume.cpp
index 345dc751604c..73167a513cde 100644
--- a/clang/test/CIR/CodeGen/builtin-assume.cpp
+++ b/clang/test/CIR/CodeGen/builtin-assume.cpp
@@ -9,7 +9,7 @@ int test_assume(int x) {
 }
 
 //      CIR: cir.func @_Z11test_assumei
-//      CIR:   %[[#x:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
+//      CIR:   %[[#x:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:   %[[#zero:]] = cir.const #cir.int<0> : !s32i
 // CIR-NEXT:   %[[#cond:]] = cir.cmp(gt, %[[#x]], %[[#zero]]) : !s32i, !cir.bool
 // CIR-NEXT:   cir.assume %[[#cond]] : !cir.bool
@@ -25,7 +25,7 @@ int test_assume_attr(int x) {
 }
 
 //      CIR: cir.func @_Z16test_assume_attri
-//      CIR:   %[[#x:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
+//      CIR:   %[[#x:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:   %[[#zero:]] = cir.const #cir.int<0> : !s32i
 // CIR-NEXT:   %[[#cond:]] = cir.cmp(gt, %[[#x]], %[[#zero]]) : !s32i, !cir.bool
 // CIR-NEXT:   cir.assume %[[#cond]] : !cir.bool
@@ -41,11 +41,11 @@ int test_assume_aligned(int *ptr) {
 }
 
 //      CIR: cir.func @_Z19test_assume_alignedPi
-//      CIR:   %[[#ptr:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#ptr:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[#aligned:]] = cir.assume.aligned %[[#ptr]] : !cir.ptr<!s32i>[alignment 8]
 // CIR-NEXT:   cir.store{{.*}} %[[#aligned]], %[[#aligned_slot:]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CIR-NEXT:   %[[#aligned2:]] = cir.load deref %[[#aligned_slot]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CIR-NEXT:   %{{.+}} = cir.load %[[#aligned2]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#aligned2:]] = cir.load deref{{.*}}  %[[#aligned_slot]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR-NEXT:   %{{.+}} = cir.load{{.*}} %[[#aligned2]] : !cir.ptr<!s32i>, !s32i
 //      CIR: }
 
 //      LLVM: @_Z19test_assume_alignedPi
@@ -59,13 +59,13 @@ int test_assume_aligned_offset(int *ptr) {
 }
 
 //      CIR: cir.func @_Z26test_assume_aligned_offsetPi
-//      CIR:   %[[#ptr:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#ptr:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[#offset:]] = cir.const #cir.int<4> : !s32i
 // CIR-NEXT:   %[[#offset2:]] = cir.cast(integral, %[[#offset]] : !s32i), !u64i
 // CIR-NEXT:   %[[#aligned:]] = cir.assume.aligned %[[#ptr]] : !cir.ptr<!s32i>[alignment 8, offset %[[#offset2]] : !u64i]
 // CIR-NEXT:   cir.store{{.*}} %[[#aligned]], %[[#aligned_slot:]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CIR-NEXT:   %[[#aligned2:]] = cir.load deref %[[#aligned_slot]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CIR-NEXT:   %{{.+}} = cir.load %[[#aligned2]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#aligned2:]] = cir.load deref{{.*}}  %[[#aligned_slot]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR-NEXT:   %{{.+}} = cir.load{{.*}} %[[#aligned2]] : !cir.ptr<!s32i>, !s32i
 //      CIR: }
 
 //      LLVM: @_Z26test_assume_aligned_offsetPi
@@ -79,9 +79,9 @@ int test_separate_storage(int *p1, int *p2) {
 }
 
 //      CIR: cir.func @_Z21test_separate_storagePiS_
-//      CIR:   %[[#p1:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#p1:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[#p1_voidptr:]] = cir.cast(bitcast, %[[#p1]] : !cir.ptr<!s32i>), !cir.ptr<!void>
-// CIR-NEXT:   %[[#p2:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CIR-NEXT:   %[[#p2:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[#p2_voidptr:]] = cir.cast(bitcast, %[[#p2]] : !cir.ptr<!s32i>), !cir.ptr<!void>
 // CIR-NEXT:   cir.assume.separate_storage %[[#p1_voidptr]], %[[#p2_voidptr]] : !cir.ptr<!void>
 //      CIR: }
diff --git a/clang/test/CIR/CodeGen/builtin-bit-cast.cpp b/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
index 5b643e7f02c1..063d64d1a821 100644
--- a/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
+++ b/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
@@ -8,9 +8,9 @@ float test_scalar(int &oper) {
 }
 
 // CIR-LABEL: cir.func @_Z11test_scalarRi
-//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//       CIR:   %[[#SRC_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 //  CIR-NEXT:   %[[#DST_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!s32i>), !cir.ptr<!cir.float>
-//  CIR-NEXT:   %{{.+}} = cir.load %[[#DST_PTR]] : !cir.ptr<!cir.float>, !cir.float
+//  CIR-NEXT:   %{{.+}} = cir.load{{.*}} %[[#DST_PTR]] : !cir.ptr<!cir.float>, !cir.float
 //       CIR: }
 
 // LLVM-LABEL: define dso_local float @_Z11test_scalarRi
@@ -28,14 +28,14 @@ unsigned long test_aggregate_to_scalar(two_ints &ti) {
 }
 
 // CIR-LABEL: cir.func @_Z24test_aggregate_to_scalarR8two_ints
-//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_two_ints>>, !cir.ptr<!rec_two_ints>
+//       CIR:   %[[#SRC_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_two_ints>>, !cir.ptr<!rec_two_ints>
 //  CIR-NEXT:   %[[#DST_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!rec_two_ints>), !cir.ptr<!u64i>
-//  CIR-NEXT:   %{{.+}} = cir.load %[[#DST_PTR]] : !cir.ptr<!u64i>, !u64i
+//  CIR-NEXT:   %{{.+}} = cir.load{{.*}} %[[#DST_PTR]] : !cir.ptr<!u64i>, !u64i
 //       CIR: }
 
 // LLVM-LABEL: define dso_local i64 @_Z24test_aggregate_to_scalarR8two_ints
 //       LLVM:   %[[#PTR:]] = load ptr, ptr %{{.+}}, align 8
-//  LLVM-NEXT:   %{{.+}} = load i64, ptr %[[#PTR]], align 8
+//  LLVM-NEXT:   %{{.+}} = load i64, ptr %[[#PTR]], align 4
 //       LLVM: }
 
 struct two_floats {
@@ -48,7 +48,7 @@ two_floats test_aggregate_record(two_ints& ti) {
 }
 
 // CIR-LABEL: cir.func @_Z21test_aggregate_recordR8two_ints
-//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_two_ints>>, !cir.ptr<!rec_two_ints>
+//       CIR:   %[[#SRC_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_two_ints>>, !cir.ptr<!rec_two_ints>
 //  CIR-NEXT:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!rec_two_ints>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!rec_two_floats>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
@@ -67,7 +67,7 @@ two_floats test_aggregate_array(int (&ary)[2]) {
 }
 
 // CIR-LABEL: cir.func @_Z20test_aggregate_arrayRA2_i
-//       CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>, !cir.ptr<!cir.array<!s32i x 2>>
+//       CIR:   %[[#SRC_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>, !cir.ptr<!cir.array<!s32i x 2>>
 //  CIR-NEXT:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!rec_two_floats>), !cir.ptr<!void>
 //  CIR-NEXT:   %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
@@ -103,14 +103,14 @@ unsigned long test_array(int (&ary)[2]) {
 }
 
 // CIR-LABEL: cir.func @_Z10test_arrayRA2_i
-//      CIR:   %[[#SRC_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>, !cir.ptr<!cir.array<!s32i x 2>>
+//      CIR:   %[[#SRC_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>, !cir.ptr<!cir.array<!s32i x 2>>
 // CIR-NEXT:   %[[#DST_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!u64i>
-// CIR-NEXT:   %{{.+}} = cir.load %[[#DST_PTR]] : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %{{.+}} = cir.load{{.*}} %[[#DST_PTR]] : !cir.ptr<!u64i>, !u64i
 //      CIR: }
 
 // LLVM-LABEL: define dso_local i64 @_Z10test_arrayRA2_i
 //       LLVM:   %[[#SRC_PTR:]] = load ptr, ptr %{{.+}}, align 8
-//  LLVM-NEXT:   %{{.+}} = load i64, ptr %[[#SRC_PTR]], align 8
+//  LLVM-NEXT:   %{{.+}} = load i64, ptr %[[#SRC_PTR]], align 4
 //       LLVM: }
 
 two_ints test_rvalue_aggregate() {
diff --git a/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp b/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp
index 216e63029ddd..7aee7a60bcc4 100644
--- a/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp
+++ b/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp
@@ -7,6 +7,6 @@ auto func() {
   // CIR-NEXT: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
   // CIR-NEXT: %1 = cir.const #cir.int<0> : !s32i
   // CIR-NEXT: cir.store %1, %0 : !s32i, !cir.ptr<!s32i>
-  // CIR-NEXT: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+  // CIR-NEXT: %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
   // CIR-NEXT: cir.return %2 : !s32i
 }
diff --git a/clang/test/CIR/CodeGen/builtin-constant-p.c b/clang/test/CIR/CodeGen/builtin-constant-p.c
index 810806ec2443..9ba08c996bec 100644
--- a/clang/test/CIR/CodeGen/builtin-constant-p.c
+++ b/clang/test/CIR/CodeGen/builtin-constant-p.c
@@ -9,11 +9,11 @@ int foo() {
 // CIR:  cir.func no_proto @foo() -> !s32i extra(#fn_attr)
 // CIR:    [[TMP0:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CIR:    [[TMP1:%.*]] = cir.get_global @a : !cir.ptr<!s32i>
-// CIR:    [[TMP2:%.*]] = cir.load [[TMP1]] : !cir.ptr<!s32i>, !s32i
+// CIR:    [[TMP2:%.*]] = cir.load{{.*}} [[TMP1]] : !cir.ptr<!s32i>, !s32i
 // CIR:    [[TMP3:%.*]] = cir.is_constant([[TMP2]] : !s32i) : !cir.bool
 // CIR:    [[TMP4:%.*]] = cir.cast(bool_to_int, [[TMP3]] : !cir.bool), !s32i
 // CIR:    cir.store [[TMP4]], [[TMP0]] : !s32i, !cir.ptr<!s32i>
-// CIR:    [[TMP5:%.*]] = cir.load [[TMP0]] : !cir.ptr<!s32i>, !s32i
+// CIR:    [[TMP5:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.return [[TMP5]] : !s32i
 
 // LLVM:define dso_local i32 @foo()
diff --git a/clang/test/CIR/CodeGen/builtin-isinf-sign.c b/clang/test/CIR/CodeGen/builtin-isinf-sign.c
index 887cf12d875c..859496d4f181 100644
--- a/clang/test/CIR/CodeGen/builtin-isinf-sign.c
+++ b/clang/test/CIR/CodeGen/builtin-isinf-sign.c
@@ -5,7 +5,7 @@
 
 int test_float_isinf_sign(float x) {
     // CIR-LABEL: test_float_isinf_sign
-    // CIR: %[[TMP0:.*]] = cir.load %{{.*}} : !cir.ptr<!cir.float>, !cir.float
+    // CIR: %[[TMP0:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.float>, !cir.float
     // CIR: %[[TMP1:.*]] = cir.fabs %[[TMP0]] : !cir.float
     // CIR: %[[IS_INF:.*]] = cir.is_fp_class %[[TMP1]], 516 : (!cir.float) -> !cir.bool
     // CIR: %[[IS_NEG:.*]] = cir.signbit %[[TMP0]] : !cir.float -> !cir.bool
diff --git a/clang/test/CIR/CodeGen/builtin-ms-alloca.c b/clang/test/CIR/CodeGen/builtin-ms-alloca.c
index baec3072d58d..8e2bd906a957 100644
--- a/clang/test/CIR/CodeGen/builtin-ms-alloca.c
+++ b/clang/test/CIR/CodeGen/builtin-ms-alloca.c
@@ -10,7 +10,7 @@ void my_win_alloca(size_t n)
 
 // CIR:       cir.func @my_win_alloca([[ALLOCA_SIZE:%.*]]: !u64i
 // CIR:       cir.store [[ALLOCA_SIZE]], [[LOCAL_VAR_ALLOCA_SIZE:%.*]] : !u64i, !cir.ptr<!u64i>
-// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
+// CIR:       [[TMP_ALLOCA_SIZE:%.*]] = cir.load{{.*}} [[LOCAL_VAR_ALLOCA_SIZE]] : !cir.ptr<!u64i>, !u64i
 // CIR:       [[ALLOCA_RES:%.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, [[TMP_ALLOCA_SIZE]] : !u64i, ["bi_alloca"] {alignment = 16 : i64}
 // CIR-NEXT:  cir.cast(bitcast, [[ALLOCA_RES]] : !cir.ptr<!u8i>), !cir.ptr<!void>
 // CIR: }
diff --git a/clang/test/CIR/CodeGen/builtin-nontemporal.cpp b/clang/test/CIR/CodeGen/builtin-nontemporal.cpp
index 522dc6efac55..8348d6ee6228 100644
--- a/clang/test/CIR/CodeGen/builtin-nontemporal.cpp
+++ b/clang/test/CIR/CodeGen/builtin-nontemporal.cpp
@@ -8,7 +8,7 @@ int nontemporal_load(const int *ptr) {
 }
 
 // CIR-LABEL: @_Z16nontemporal_loadPKi
-// CIR: %{{.+}} = cir.load nontemporal %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR: %{{.+}} = cir.load nontemporal{{.*}}  %{{.+}} : !cir.ptr<!s32i>, !s32i
 
 // LLVM-LABEL: @_Z16nontemporal_loadPKi
 // LLVM: %{{.+}} = load i32, ptr %{{.+}}, align 4, !nontemporal !1
diff --git a/clang/test/CIR/CodeGen/builtin-prefetch.c b/clang/test/CIR/CodeGen/builtin-prefetch.c
index 56ac9a70ddb4..c6aa093da734 100644
--- a/clang/test/CIR/CodeGen/builtin-prefetch.c
+++ b/clang/test/CIR/CodeGen/builtin-prefetch.c
@@ -8,7 +8,7 @@ void foo(void *a) {
 // CIR:  cir.func @foo(%arg0: !cir.ptr<!void> loc({{.*}}))
 // CIR:    [[PTR_ALLOC:%.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["a", init] {alignment = 8 : i64}
 // CIR:    cir.store %arg0, [[PTR_ALLOC]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
-// CIR:    [[PTR:%.*]] = cir.load [[PTR_ALLOC]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR:    [[PTR:%.*]] = cir.load{{.*}} [[PTR_ALLOC]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR:    cir.prefetch([[PTR]] : !cir.ptr<!void>) locality(1) write
 // CIR:    cir.return
 
diff --git a/clang/test/CIR/CodeGen/builtins-memory.c b/clang/test/CIR/CodeGen/builtins-memory.c
index 9c7a74301aaa..0a597379c9b8 100644
--- a/clang/test/CIR/CodeGen/builtins-memory.c
+++ b/clang/test/CIR/CodeGen/builtins-memory.c
@@ -14,14 +14,14 @@ void test_memcpy_chk(void *dest, const void *src, size_t n) {
   // An unchecked memcpy should be emitted when the count and buffer size are
   // constants and the count is less than or equal to the buffer size.
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<8>
   // CIR: cir.libc.memcpy %[[#COUNT]] bytes from %[[#SRC_LOAD]] to %[[#DEST_LOAD]]
   __builtin___memcpy_chk(dest, src, 8, 10);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
   // CIR: cir.libc.memcpy %[[#COUNT]] bytes from %[[#SRC_LOAD]] to %[[#DEST_LOAD]]
   __builtin___memcpy_chk(dest, src, 10, 10);
@@ -29,31 +29,31 @@ void test_memcpy_chk(void *dest, const void *src, size_t n) {
   // __memcpy_chk should be called when the count is greater than the buffer
   // size, or when either the count or buffer size isn't a constant.
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
   // CIR: %[[#SIZE:]] = cir.const #cir.int<8>
   // CIR: cir.call @__memcpy_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#COUNT]], %[[#SIZE]])
   __builtin___memcpy_chk(dest, src, 10lu, 8lu);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
-  // CIR: %[[#N_LOAD:]] = cir.load %[[#N]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
+  // CIR: %[[#N_LOAD:]] = cir.load{{.*}} %[[#N]]
   // CIR: %[[#SIZE:]] = cir.const #cir.int<10>
   // CIR: cir.call @__memcpy_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#N_LOAD]], %[[#SIZE]])
   __builtin___memcpy_chk(dest, src, n, 10lu);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
-  // CIR: %[[#N_LOAD:]] = cir.load %[[#N]]
+  // CIR: %[[#N_LOAD:]] = cir.load{{.*}} %[[#N]]
   // CIR: cir.call @__memcpy_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#COUNT]], %[[#N_LOAD]])
   __builtin___memcpy_chk(dest, src, 10lu, n);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
-  // CIR: %[[#N_LOAD1:]] = cir.load %[[#N]]
-  // CIR: %[[#N_LOAD2:]] = cir.load %[[#N]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
+  // CIR: %[[#N_LOAD1:]] = cir.load{{.*}} %[[#N]]
+  // CIR: %[[#N_LOAD2:]] = cir.load{{.*}} %[[#N]]
   // CIR: cir.call @__memcpy_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#N_LOAD1]], %[[#N_LOAD2]])
   __builtin___memcpy_chk(dest, src, n, n);
 }
@@ -69,24 +69,24 @@ void test_memmove_chk(void *dest, const void *src, size_t n) {
   // An unchecked memmove should be emitted when the count and buffer size are
   // constants and the count is less than or equal to the buffer size.
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<8>
   // CIR: cir.libc.memmove %[[#COUNT]] bytes from %[[#SRC_LOAD]] to %[[#DEST_LOAD]]
   // LLVM: call void @llvm.memmove.p0.p0.i64(ptr {{%.*}}, ptr {{%.*}}, i64 8, i1 false)
   // COM: LLVM: call void @llvm.memmove.p0.p0.i64(ptr align 1 {{%.*}}, ptr align 1 {{%.*}}, i64 8, i1 false)
   __builtin___memmove_chk(dest, src, 8, 10);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
   // CIR: cir.libc.memmove %[[#COUNT]] bytes from %[[#SRC_LOAD]] to %[[#DEST_LOAD]]
   // LLVM: call void @llvm.memmove.p0.p0.i64(ptr {{%.*}}, ptr {{%.*}}, i64 10, i1 false)
   // COM: LLVM: call void @llvm.memmove.p0.p0.i64(ptr align 1 {{%.*}}, ptr align 1 {{%.*}}, i64 10, i1 false)
   __builtin___memmove_chk(dest, src, 10, 10);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
   // CIR: %[[#SIZE:]] = cir.const #cir.int<8>
   // CIR: cir.call @__memmove_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#COUNT]], %[[#SIZE]])
@@ -94,28 +94,28 @@ void test_memmove_chk(void *dest, const void *src, size_t n) {
   // COM: LLVM: call ptr @__memmove_chk(ptr noundef %4, ptr noundef %5, i64 noundef 10, i64 noundef 8)
   __builtin___memmove_chk(dest, src, 10lu, 8lu);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
-  // CIR: %[[#N_LOAD:]] = cir.load %[[#N]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
+  // CIR: %[[#N_LOAD:]] = cir.load{{.*}} %[[#N]]
   // CIR: %[[#SIZE:]] = cir.const #cir.int<10>
   // CIR: cir.call @__memmove_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#N_LOAD]], %[[#SIZE]])
   // LLVM: call ptr @__memmove_chk(ptr {{%.*}}, ptr {{%.*}}, i64 {{%.*}}, i64 10)
   // COM: LLVM: call ptr @__memmove_chk(ptr noundef {{%.*}}, ptr noundef {{%.*}}, i64 noundef {{%.*}}, i64 noundef 10)
   __builtin___memmove_chk(dest, src, n, 10lu);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
-  // CIR: %[[#N_LOAD:]] = cir.load %[[#N]]
+  // CIR: %[[#N_LOAD:]] = cir.load{{.*}} %[[#N]]
   // CIR: cir.call @__memmove_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#COUNT]], %[[#N_LOAD]])
   // LLVM: call ptr @__memmove_chk(ptr {{%.*}}, ptr {{%.*}}, i64 10, i64 {{%.*}})
   // COM: LLVM: call ptr @__memmove_chk(ptr noundef {{%.*}}, ptr noundef {{%.*}}, i64 noundef 10, i64 noundef {{%.*}})
   __builtin___memmove_chk(dest, src, 10lu, n);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#SRC_LOAD:]] = cir.load %[[#SRC]]
-  // CIR: %[[#N_LOAD1:]] = cir.load %[[#N]]
-  // CIR: %[[#N_LOAD2:]] = cir.load %[[#N]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#SRC_LOAD:]] = cir.load{{.*}} %[[#SRC]]
+  // CIR: %[[#N_LOAD1:]] = cir.load{{.*}} %[[#N]]
+  // CIR: %[[#N_LOAD2:]] = cir.load{{.*}} %[[#N]]
   // CIR: cir.call @__memmove_chk(%[[#DEST_LOAD]], %[[#SRC_LOAD]], %[[#N_LOAD1]], %[[#N_LOAD2]])
   // LLVM: call ptr @__memmove_chk(ptr {{%.*}}, ptr {{%.*}}, i64 {{%.*}}, i64 {{%.*}})
   // COM: LLVM: call ptr @__memmove_chk(ptr noundef {{%.*}}, ptr noundef {{%.*}}, i64 noundef {{%.*}}, i64 noundef {{%.*}})
@@ -132,14 +132,14 @@ void test_memset_chk(void *dest, int ch, size_t n) {
   // An unchecked memset should be emitted when the count and buffer size are
   // constants and the count is less than or equal to the buffer size.
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#CH_LOAD:]] = cir.load %[[#CH]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#CH_LOAD:]] = cir.load{{.*}} %[[#CH]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<8>
   // CIR: cir.libc.memset %[[#COUNT]] bytes from %[[#DEST_LOAD]] set to %[[#CH_LOAD]]
   __builtin___memset_chk(dest, ch, 8, 10);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#CH_LOAD:]] = cir.load %[[#CH]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#CH_LOAD:]] = cir.load{{.*}} %[[#CH]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
   // CIR: cir.libc.memset %[[#COUNT]] bytes from %[[#DEST_LOAD]] set to %[[#CH_LOAD]]
   __builtin___memset_chk(dest, ch, 10, 10);
@@ -147,31 +147,31 @@ void test_memset_chk(void *dest, int ch, size_t n) {
   // __memset_chk should be called when the count is greater than the buffer
   // size, or when either the count or buffer size isn't a constant.
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#CH_LOAD:]] = cir.load %[[#CH]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#CH_LOAD:]] = cir.load{{.*}} %[[#CH]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
   // CIR: %[[#SIZE:]] = cir.const #cir.int<8>
   // CIR: cir.call @__memset_chk(%[[#DEST_LOAD]], %[[#CH_LOAD]], %[[#COUNT]], %[[#SIZE]])
   __builtin___memset_chk(dest, ch, 10lu, 8lu);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#CH_LOAD:]] = cir.load %[[#CH]]
-  // CIR: %[[#N_LOAD:]] = cir.load %[[#N]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#CH_LOAD:]] = cir.load{{.*}} %[[#CH]]
+  // CIR: %[[#N_LOAD:]] = cir.load{{.*}} %[[#N]]
   // CIR: %[[#SIZE:]] = cir.const #cir.int<10>
   // CIR: cir.call @__memset_chk(%[[#DEST_LOAD]], %[[#CH_LOAD]], %[[#N_LOAD]], %[[#SIZE]])
   __builtin___memset_chk(dest, ch, n, 10lu);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#CH_LOAD:]] = cir.load %[[#CH]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#CH_LOAD:]] = cir.load{{.*}} %[[#CH]]
   // CIR: %[[#COUNT:]] = cir.const #cir.int<10>
-  // CIR: %[[#N_LOAD:]] = cir.load %[[#N]]
+  // CIR: %[[#N_LOAD:]] = cir.load{{.*}} %[[#N]]
   // CIR: cir.call @__memset_chk(%[[#DEST_LOAD]], %[[#CH_LOAD]], %[[#COUNT]], %[[#N_LOAD]])
   __builtin___memset_chk(dest, ch, 10lu, n);
 
-  // CIR: %[[#DEST_LOAD:]] = cir.load %[[#DEST]]
-  // CIR: %[[#CH_LOAD:]] = cir.load %[[#CH]]
-  // CIR: %[[#N_LOAD1:]] = cir.load %[[#N]]
-  // CIR: %[[#N_LOAD2:]] = cir.load %[[#N]]
+  // CIR: %[[#DEST_LOAD:]] = cir.load{{.*}} %[[#DEST]]
+  // CIR: %[[#CH_LOAD:]] = cir.load{{.*}} %[[#CH]]
+  // CIR: %[[#N_LOAD1:]] = cir.load{{.*}} %[[#N]]
+  // CIR: %[[#N_LOAD2:]] = cir.load{{.*}} %[[#N]]
   // CIR: cir.call @__memset_chk(%[[#DEST_LOAD]], %[[#CH_LOAD]], %[[#N_LOAD1]], %[[#N_LOAD2]])
   __builtin___memset_chk(dest, ch, n, n);
 }
diff --git a/clang/test/CIR/CodeGen/builtins-overflow.cpp b/clang/test/CIR/CodeGen/builtins-overflow.cpp
index 2057f8659e77..70343c4d7339 100644
--- a/clang/test/CIR/CodeGen/builtins-overflow.cpp
+++ b/clang/test/CIR/CodeGen/builtins-overflow.cpp
@@ -6,9 +6,9 @@ bool test_add_overflow_uint_uint_uint(unsigned x, unsigned y, unsigned *res) {
 }
 
 //      CIR: cir.func @_Z32test_add_overflow_uint_uint_uintjjPj
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#LHS]], %[[#RHS]]) : !u32i, (!u32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u32i, !cir.ptr<!u32i>
 //      CIR: }
@@ -18,9 +18,9 @@ bool test_add_overflow_int_int_int(int x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z29test_add_overflow_int_int_intiiPi
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#LHS]], %[[#RHS]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -30,9 +30,9 @@ bool test_add_overflow_xint31_xint31_xint31(_BitInt(31) x, _BitInt(31) y, _BitIn
 }
 
 //      CIR: cir.func @_Z38test_add_overflow_xint31_xint31_xint31DB31_S_PS_
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.int<s, 31>>>, !cir.ptr<!cir.int<s, 31>>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.int<s, 31>>>, !cir.ptr<!cir.int<s, 31>>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#LHS]], %[[#RHS]]) : <s, 31>, (<s, 31>, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !cir.int<s, 31>, !cir.ptr<!cir.int<s, 31>>
 //      CIR: }
@@ -42,9 +42,9 @@ bool test_sub_overflow_uint_uint_uint(unsigned x, unsigned y, unsigned *res) {
 }
 
 //      CIR: cir.func @_Z32test_sub_overflow_uint_uint_uintjjPj
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#LHS]], %[[#RHS]]) : !u32i, (!u32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u32i, !cir.ptr<!u32i>
 //      CIR: }
@@ -54,9 +54,9 @@ bool test_sub_overflow_int_int_int(int x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z29test_sub_overflow_int_int_intiiPi
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#LHS]], %[[#RHS]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -66,9 +66,9 @@ bool test_sub_overflow_xint31_xint31_xint31(_BitInt(31) x, _BitInt(31) y, _BitIn
 }
 
 //      CIR: cir.func @_Z38test_sub_overflow_xint31_xint31_xint31DB31_S_PS_
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.int<s, 31>>>, !cir.ptr<!cir.int<s, 31>>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.int<s, 31>>>, !cir.ptr<!cir.int<s, 31>>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#LHS]], %[[#RHS]]) : <s, 31>, (<s, 31>, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !cir.int<s, 31>, !cir.ptr<!cir.int<s, 31>>
 //      CIR: }
@@ -78,9 +78,9 @@ bool test_mul_overflow_uint_uint_uint(unsigned x, unsigned y, unsigned *res) {
 }
 
 //      CIR: cir.func @_Z32test_mul_overflow_uint_uint_uintjjPj
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#LHS]], %[[#RHS]]) : !u32i, (!u32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u32i, !cir.ptr<!u32i>
 //      CIR: }
@@ -90,9 +90,9 @@ bool test_mul_overflow_int_int_int(int x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z29test_mul_overflow_int_int_intiiPi
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#LHS]], %[[#RHS]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -102,9 +102,9 @@ bool test_mul_overflow_xint31_xint31_xint31(_BitInt(31) x, _BitInt(31) y, _BitIn
 }
 
 //      CIR: cir.func @_Z38test_mul_overflow_xint31_xint31_xint31DB31_S_PS_
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.int<s, 31>>>, !cir.ptr<!cir.int<s, 31>>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.int<s, 31>>, !cir.int<s, 31>
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.int<s, 31>>>, !cir.ptr<!cir.int<s, 31>>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#LHS]], %[[#RHS]]) : <s, 31>, (<s, 31>, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !cir.int<s, 31>, !cir.ptr<!cir.int<s, 31>>
 //      CIR: }
@@ -114,9 +114,9 @@ bool test_mul_overflow_ulong_ulong_long(unsigned long x, unsigned long y, unsign
 }
 
 //      CIR: cir.func @_Z34test_mul_overflow_ulong_ulong_longmmPm
-//      CIR:   %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#LHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RHS:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#LHS]], %[[#RHS]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -126,9 +126,9 @@ bool test_add_overflow_uint_int_int(unsigned x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z30test_add_overflow_uint_int_intjiPi
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[#PROM_X:]] = cir.cast(integral, %[[#X]] : !u32i), !cir.int<s, 33>
 // CIR-NEXT:   %[[#PROM_Y:]] = cir.cast(integral, %[[#Y]] : !s32i), !cir.int<s, 33>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#PROM_X]], %[[#PROM_Y]]) : <s, 33>, (!s32i, !cir.bool)
@@ -140,9 +140,9 @@ bool test_add_overflow_volatile(int x, int y, volatile int *res) {
 }
 
 //      CIR: cir.func @_Z26test_add_overflow_volatileiiPVi
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store volatile{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -152,9 +152,9 @@ bool test_uadd_overflow(unsigned x, unsigned y, unsigned *res) {
 }
 
 //      CIR: cir.func @_Z18test_uadd_overflowjjPj
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !u32i, (!u32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u32i, !cir.ptr<!u32i>
 //      CIR: }
@@ -164,9 +164,9 @@ bool test_uaddl_overflow(unsigned long x, unsigned long y, unsigned long *res) {
 }
 
 //      CIR: cir.func @_Z19test_uaddl_overflowmmPm
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -176,9 +176,9 @@ bool test_uaddll_overflow(unsigned long long x, unsigned long long y, unsigned l
 }
 
 //      CIR: cir.func @_Z20test_uaddll_overflowyyPy
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -188,9 +188,9 @@ bool test_usub_overflow(unsigned x, unsigned y, unsigned *res) {
 }
 
 //      CIR: cir.func @_Z18test_usub_overflowjjPj
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#X]], %[[#Y]]) : !u32i, (!u32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u32i, !cir.ptr<!u32i>
 //      CIR: }
@@ -200,9 +200,9 @@ bool test_usubl_overflow(unsigned long x, unsigned long y, unsigned long *res) {
 }
 
 //      CIR: cir.func @_Z19test_usubl_overflowmmPm
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#X]], %[[#Y]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -212,9 +212,9 @@ bool test_usubll_overflow(unsigned long long x, unsigned long long y, unsigned l
 }
 
 //      CIR: cir.func @_Z20test_usubll_overflowyyPy
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#X]], %[[#Y]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -224,9 +224,9 @@ bool test_umul_overflow(unsigned x, unsigned y, unsigned *res) {
 }
 
 //      CIR: cir.func @_Z18test_umul_overflowjjPj
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#X]], %[[#Y]]) : !u32i, (!u32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u32i, !cir.ptr<!u32i>
 //      CIR: }
@@ -236,9 +236,9 @@ bool test_umull_overflow(unsigned long x, unsigned long y, unsigned long *res) {
 }
 
 //      CIR: cir.func @_Z19test_umull_overflowmmPm
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#X]], %[[#Y]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -248,9 +248,9 @@ bool test_umulll_overflow(unsigned long long x, unsigned long long y, unsigned l
 }
 
 //      CIR: cir.func @_Z20test_umulll_overflowyyPy
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!u64i>, !u64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u64i>, !u64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#X]], %[[#Y]]) : !u64i, (!u64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !u64i, !cir.ptr<!u64i>
 //      CIR: }
@@ -260,9 +260,9 @@ bool test_sadd_overflow(int x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z18test_sadd_overflowiiPi
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -272,9 +272,9 @@ bool test_saddl_overflow(long x, long y, long *res) {
 }
 
 //      CIR: cir.func @_Z19test_saddl_overflowllPl
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !s64i, (!s64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s64i, !cir.ptr<!s64i>
 //      CIR: }
@@ -284,9 +284,9 @@ bool test_saddll_overflow(long long x, long long y, long long *res) {
 }
 
 //      CIR: cir.func @_Z20test_saddll_overflowxxPx
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(add, %[[#X]], %[[#Y]]) : !s64i, (!s64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s64i, !cir.ptr<!s64i>
 //      CIR: }
@@ -296,9 +296,9 @@ bool test_ssub_overflow(int x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z18test_ssub_overflowiiPi
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#X]], %[[#Y]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -308,9 +308,9 @@ bool test_ssubl_overflow(long x, long y, long *res) {
 }
 
 //      CIR: cir.func @_Z19test_ssubl_overflowllPl
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#X]], %[[#Y]]) : !s64i, (!s64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s64i, !cir.ptr<!s64i>
 //      CIR: }
@@ -320,9 +320,9 @@ bool test_ssubll_overflow(long long x, long long y, long long *res) {
 }
 
 //      CIR: cir.func @_Z20test_ssubll_overflowxxPx
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(sub, %[[#X]], %[[#Y]]) : !s64i, (!s64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s64i, !cir.ptr<!s64i>
 //      CIR: }
@@ -332,9 +332,9 @@ bool test_smul_overflow(int x, int y, int *res) {
 }
 
 //      CIR: cir.func @_Z18test_smul_overflowiiPi
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#X]], %[[#Y]]) : !s32i, (!s32i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
@@ -344,9 +344,9 @@ bool test_smull_overflow(long x, long y, long *res) {
 }
 
 //      CIR: cir.func @_Z19test_smull_overflowllPl
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#X]], %[[#Y]]) : !s64i, (!s64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s64i, !cir.ptr<!s64i>
 //      CIR: }
@@ -356,9 +356,9 @@ bool test_smulll_overflow(long long x, long long y, long long *res) {
 }
 
 //      CIR: cir.func @_Z20test_smulll_overflowxxPx
-//      CIR:   %[[#X:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#Y:]] = cir.load %{{.+}} : !cir.ptr<!s64i>, !s64i
-// CIR-NEXT:   %[[#RES_PTR:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+//      CIR:   %[[#X:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#Y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s64i>, !s64i
+// CIR-NEXT:   %[[#RES_PTR:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // CIR-NEXT:   %[[RES:.+]], %{{.+}} = cir.binop.overflow(mul, %[[#X]], %[[#Y]]) : !s64i, (!s64i, !cir.bool)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s64i, !cir.ptr<!s64i>
 //      CIR: }
diff --git a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
index 3993f4bfd49b..3f9914e5b02c 100644
--- a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
+++ b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
@@ -24,10 +24,10 @@ void fn1() { f f1; }
 
 // CIR: cir.func @_ZN1f1bEv(%arg0: !cir.ptr<!rec_f> loc{{.*}}) -> !cir.ptr<!s8i>
 // CIR: [[H_PTR:%.*]] = cir.get_global @h : !cir.ptr<!s32i> loc(#loc18)
-// CIR: [[H_VAL:%.*]] = cir.load [[H_PTR]] : !cir.ptr<!s32i>, !s32i
+// CIR: [[H_VAL:%.*]] = cir.load{{.*}} [[H_PTR]] : !cir.ptr<!s32i>, !s32i
 // CIR: [[RET1_VAL:%.*]] = cir.call @_ZN1a1bEi([[H_VAL]]) : (!s32i) -> !cir.ptr<!s8i>
 // CIR: cir.store [[RET1_VAL]], [[RET1_P:%.*]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CIR: [[RET1_VAL2:%.*]] = cir.load [[RET1_P]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+// CIR: [[RET1_VAL2:%.*]] = cir.load{{.*}} [[RET1_P]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
 //    %7 = cir.load %1 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
 // CIR: cir.return [[RET1_VAL2]] : !cir.ptr<!s8i>
 
diff --git a/clang/test/CIR/CodeGen/call.c b/clang/test/CIR/CodeGen/call.c
index 2c3d5cfa151e..5f5e5e1124f6 100644
--- a/clang/test/CIR/CodeGen/call.c
+++ b/clang/test/CIR/CodeGen/call.c
@@ -24,11 +24,11 @@ void d(void) {
 // CHECK:     %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
 // CHECK:     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
 // CHECK:     cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK:     %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-// CHECK:     %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %3 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %4 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK:     %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK:     cir.store %5, %2 : !s32i, !cir.ptr<!s32i>
-// CHECK:     %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %6 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // CHECK:     cir.return %6
 // CHECK:   }
 // CHECK:   cir.func @c(%arg0: !cir.double {{.*}}, %arg1: !cir.double {{.*}}) -> !cir.double
@@ -37,11 +37,11 @@ void d(void) {
 // CHECK:     %2 = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["__retval"]
 // CHECK:     cir.store %arg0, %0 : !cir.double, !cir.ptr<!cir.double>
 // CHECK:     cir.store %arg1, %1 : !cir.double, !cir.ptr<!cir.double>
-// CHECK:     %3 = cir.load %0 : !cir.ptr<!cir.double>, !cir.double
-// CHECK:     %4 = cir.load %1 : !cir.ptr<!cir.double>, !cir.double
+// CHECK:     %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.double>, !cir.double
+// CHECK:     %4 = cir.load{{.*}} %1 : !cir.ptr<!cir.double>, !cir.double
 // CHECK:     %5 = cir.binop(add, %3, %4) : !cir.double
 // CHECK:     cir.store %5, %2 : !cir.double, !cir.ptr<!cir.double>
-// CHECK:     %6 = cir.load %2 : !cir.ptr<!cir.double>, !cir.double
+// CHECK:     %6 = cir.load{{.*}} %2 : !cir.ptr<!cir.double>, !cir.double
 // CHECK:     cir.return %6 : !cir.double
 // CHECK:   }
 // CHECK:   cir.func @d()
@@ -62,11 +62,11 @@ void d(void) {
 // CXX-NEXT:     %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
 // CXX-NEXT:     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
 // CXX-NEXT:     cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CXX-NEXT:     %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-// CXX-NEXT:     %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CXX-NEXT:     %3 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
+// CXX-NEXT:     %4 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CXX-NEXT:     %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CXX-NEXT:     cir.store %5, %2 : !s32i, !cir.ptr<!s32i>
-// CXX-NEXT:     %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// CXX-NEXT:     %6 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // CXX-NEXT:     cir.return %6
 // CXX-NEXT:   }
 // CXX-NEXT:   cir.func @_Z1cdd(%arg0: !cir.double {{.*}}, %arg1: !cir.double {{.*}}) -> !cir.double
@@ -75,11 +75,11 @@ void d(void) {
 // CXX-NEXT:     %2 = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["__retval"]
 // CXX-NEXT:     cir.store %arg0, %0 : !cir.double, !cir.ptr<!cir.double>
 // CXX-NEXT:     cir.store %arg1, %1 : !cir.double, !cir.ptr<!cir.double>
-// CXX-NEXT:     %3 = cir.load %0 : !cir.ptr<!cir.double>, !cir.double
-// CXX-NEXT:     %4 = cir.load %1 : !cir.ptr<!cir.double>, !cir.double
+// CXX-NEXT:     %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.double>, !cir.double
+// CXX-NEXT:     %4 = cir.load{{.*}} %1 : !cir.ptr<!cir.double>, !cir.double
 // CXX-NEXT:     %5 = cir.binop(add, %3, %4) : !cir.double
 // CXX-NEXT:     cir.store %5, %2 : !cir.double, !cir.ptr<!cir.double>
-// CXX-NEXT:     %6 = cir.load %2 : !cir.ptr<!cir.double>, !cir.double
+// CXX-NEXT:     %6 = cir.load{{.*}} %2 : !cir.ptr<!cir.double>, !cir.double
 // CXX-NEXT:     cir.return %6 : !cir.double
 // CXX-NEXT:   }
 // CXX-NEXT:   cir.func @_Z1dv()
diff --git a/clang/test/CIR/CodeGen/call.cpp b/clang/test/CIR/CodeGen/call.cpp
index 26db637fdb1d..09c3bc80d9ac 100644
--- a/clang/test/CIR/CodeGen/call.cpp
+++ b/clang/test/CIR/CodeGen/call.cpp
@@ -9,6 +9,6 @@ int f() {
 // CHECK: cir.func @_Z1fv() -> !s32i
 // CHECK:   %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK:   %1 = cir.call @_Z1pv() : () -> !cir.ptr<!s32i>
-// CHECK:   %2 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK:   %2 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK:   %3 = cir.const #cir.int<22> : !s32i
 // CHECK:   %4 = cir.binop(sub, %2, %3) nsw : !s32i
diff --git a/clang/test/CIR/CodeGen/cast.c b/clang/test/CIR/CodeGen/cast.c
index 2ec2e47f6fb9..ad76d7f46032 100644
--- a/clang/test/CIR/CodeGen/cast.c
+++ b/clang/test/CIR/CodeGen/cast.c
@@ -13,8 +13,8 @@ int cstyle_cast_lvalue(A a) {
 // CHECK:    [[ALLOC_RET:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK:    cir.store{{.*}} %arg0, [[ALLOC_A]] : !rec_A, !cir.ptr<!rec_A>
 // CHECK:    [[X_ADDR:%.*]] = cir.get_member [[ALLOC_A]][0] {name = "x"} : !cir.ptr<!rec_A> -> !cir.ptr<!s32i>
-// CHECK:    [[X:%.*]] = cir.load [[X_ADDR]] : !cir.ptr<!s32i>, !s32i
+// CHECK:    [[X:%.*]] = cir.load{{.*}} [[X_ADDR]] : !cir.ptr<!s32i>, !s32i
 // CHECK:    cir.store{{.*}} [[X]], [[ALLOC_RET]] : !s32i, !cir.ptr<!s32i>
-// CHECK:    [[RET:%.*]] = cir.load [[ALLOC_RET]] : !cir.ptr<!s32i>, !s32i
+// CHECK:    [[RET:%.*]] = cir.load{{.*}} [[ALLOC_RET]] : !cir.ptr<!s32i>, !s32i
 // CHECK:    cir.return [[RET]] : !s32i
 
diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp
index 69831eceba01..0c62d7ce5e14 100644
--- a/clang/test/CIR/CodeGen/cast.cpp
+++ b/clang/test/CIR/CodeGen/cast.cpp
@@ -9,10 +9,10 @@ unsigned char cxxstaticcast_0(unsigned int x) {
 // CHECK:    %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] {alignment = 4 : i64}
 // CHECK:    %1 = cir.alloca !u8i, !cir.ptr<!u8i>, ["__retval"] {alignment = 1 : i64}
 // CHECK:    cir.store{{.*}} %arg0, %0 : !u32i, !cir.ptr<!u32i>
-// CHECK:    %2 = cir.load %0 : !cir.ptr<!u32i>, !u32i
+// CHECK:    %2 = cir.load{{.*}} %0 : !cir.ptr<!u32i>, !u32i
 // CHECK:    %3 = cir.cast(integral, %2 : !u32i), !u8i
 // CHECK:    cir.store{{.*}} %3, %1 : !u8i, !cir.ptr<!u8i>
-// CHECK:    %4 = cir.load %1 : !cir.ptr<!u8i>, !u8i
+// CHECK:    %4 = cir.load{{.*}} %1 : !cir.ptr<!u8i>, !u8i
 // CHECK:    cir.return %4 : !u8i
 // CHECK:  }
 
@@ -94,7 +94,7 @@ bool cptr(void *d) {
 // CHECK: cir.func @_Z4cptrPv(%arg0: !cir.ptr<!void>
 // CHECK:   %0 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["d", init] {alignment = 8 : i64}
 
-// CHECK:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CHECK:   %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CHECK:   %4 = cir.cast(ptr_to_bool, %3 : !cir.ptr<!void>), !cir.bool
 
 void call_cptr(void *d) {
@@ -106,7 +106,7 @@ void call_cptr(void *d) {
 // CHECK:   %0 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["d", init] {alignment = 8 : i64}
 
 // CHECK:   cir.scope {
-// CHECK:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CHECK:     %1 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CHECK:     %2 = cir.call @_Z4cptrPv(%1) : (!cir.ptr<!void>) -> !cir.bool
 // CHECK:     %3 = cir.unary(not, %2) : !cir.bool, !cir.bool
 // CHECK:     cir.if %3 {
diff --git a/clang/test/CIR/CodeGen/comma.cpp b/clang/test/CIR/CodeGen/comma.cpp
index 55ce4e1deabb..c523d2136fdb 100644
--- a/clang/test/CIR/CodeGen/comma.cpp
+++ b/clang/test/CIR/CodeGen/comma.cpp
@@ -11,9 +11,9 @@ int c0() {
 // CHECK: %[[#RET:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
 // CHECK: %[[#B:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CHECK: %[[#LOADED_B:]] = cir.load %[[#B]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[#LOADED_B:]] = cir.load{{.*}} %[[#B]] : !cir.ptr<!s32i>, !s32i
 // CHECK: %[[#]] = cir.binop(add, %[[#LOADED_B]], %[[#]]) nsw : !s32i
-// CHECK: %[[#LOADED_A:]] = cir.load %[[#A]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[#LOADED_A:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} %[[#LOADED_A]], %[[#RET]] : !s32i, !cir.ptr<!s32i>
 
 int &foo1();
diff --git a/clang/test/CIR/CodeGen/complex-cast.c b/clang/test/CIR/CodeGen/complex-cast.c
index 5cadcf711a60..95789e5abd4a 100644
--- a/clang/test/CIR/CodeGen/complex-cast.c
+++ b/clang/test/CIR/CodeGen/complex-cast.c
@@ -24,20 +24,20 @@ void scalar_to_complex() {
 
 // CIR-BEFORE: %{{.+}} = cir.cast(float_to_complex, %{{.+}} : !cir.double), !cir.complex<!cir.double>
 
-//      CIR-AFTER: %[[#REAL:]] = cir.load volatile %{{.+}} : !cir.ptr<!cir.double>, !cir.double
+//      CIR-AFTER: %[[#REAL:]] = cir.load volatile{{.*}}  %{{.+}} : !cir.ptr<!cir.double>, !cir.double
 // CIR-AFTER-NEXT: %[[#IMAG:]] = cir.const #cir.fp<0.000000e+00> : !cir.double
 // CIR-AFTER-NEXT: %{{.+}} = cir.complex.create %[[#REAL]], %[[#IMAG]] : !cir.double -> !cir.complex<!cir.double>
 
 // CIR-BEFORE: %{{.+}} = cir.cast(int_to_complex, %{{.+}} : !s32i), !cir.complex<!s32i>
 
-//      CIR-AFTER: %[[#REAL:]] = cir.load volatile %{{.+}} : !cir.ptr<!s32i>, !s32i
+//      CIR-AFTER: %[[#REAL:]] = cir.load volatile{{.*}}  %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CIR-AFTER-NEXT: %[[#IMAG:]] = cir.const #cir.int<0> : !s32i
 // CIR-AFTER-NEXT: %{{.+}} = cir.complex.create %[[#REAL]], %[[#IMAG]] : !s32i -> !cir.complex<!s32i>
 
 //      CIR-BEFORE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.double
 // CIR-BEFORE-NEXT: %{{.+}} = cir.cast(float_to_complex, %[[#A]] : !cir.double), !cir.complex<!cir.double>
 
-//      CIR-AFTER: %[[#A:]] = cir.load volatile %{{.+}} : !cir.ptr<!s32i>, !s32i
+//      CIR-AFTER: %[[#A:]] = cir.load volatile{{.*}}  %{{.+}} : !cir.ptr<!s32i>, !s32i
 // CIR-AFTER-NEXT: %[[#REAL:]] = cir.cast(int_to_float, %[[#A]] : !s32i), !cir.double
 // CIR-AFTER-NEXT: %[[#IMAG:]] = cir.const #cir.fp<0.000000e+00> : !cir.double
 // CIR-AFTER-NEXT: %{{.+}} = cir.complex.create %[[#REAL]], %[[#IMAG]] : !cir.double -> !cir.complex<!cir.double>
@@ -45,7 +45,7 @@ void scalar_to_complex() {
 //      CIR-BEFORE: %[[#A:]] = cir.cast(float_to_int, %{{.+}} : !cir.double), !s32i
 // CIR-BEFORE-NEXT: %{{.+}} = cir.cast(int_to_complex, %[[#A]] : !s32i), !cir.complex<!s32i>
 
-//      CIR-AFTER: %[[#A:]] = cir.load volatile %{{.+}} : !cir.ptr<!cir.double>, !cir.double
+//      CIR-AFTER: %[[#A:]] = cir.load volatile{{.*}}  %{{.+}} : !cir.ptr<!cir.double>, !cir.double
 // CIR-AFTER-NEXT: %[[#REAL:]] = cir.cast(float_to_int, %[[#A]] : !cir.double), !s32i
 // CIR-AFTER-NEXT: %[[#IMAG:]] = cir.const #cir.int<0> : !s32i
 // CIR-AFTER-NEXT: %{{.+}} = cir.complex.create %[[#REAL]], %[[#IMAG]] : !s32i -> !cir.complex<!s32i>
diff --git a/clang/test/CIR/CodeGen/complex.c b/clang/test/CIR/CodeGen/complex.c
index d4eb71e4fd9a..27924f813394 100644
--- a/clang/test/CIR/CodeGen/complex.c
+++ b/clang/test/CIR/CodeGen/complex.c
@@ -39,15 +39,15 @@ void list_init_2(double r, double i) {
 }
 
 //      CHECK-BEFORE: cir.func
-//      CHECK-BEFORE:   %[[#R:]] = cir.load %{{.+}} : !cir.ptr<!cir.double>, !cir.double
-// CHECK-BEFORE-NEXT:   %[[#I:]] = cir.load %{{.+}} : !cir.ptr<!cir.double>, !cir.double
+//      CHECK-BEFORE:   %[[#R:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.double>, !cir.double
+// CHECK-BEFORE-NEXT:   %[[#I:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.double>, !cir.double
 // CHECK-BEFORE-NEXT:   %[[#C:]] = cir.complex.create %[[#R]], %[[#I]] : !cir.double -> !cir.complex<!cir.double>
 // CHECK-BEFORE-NEXT:   cir.store{{.*}} %[[#C]], %{{.+}} : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
-//      CHECK-AFTER:   %[[#R:]] = cir.load %{{.+}} : !cir.ptr<!cir.double>, !cir.double
-// CHECK-AFTER-NEXT:   %[[#I:]] = cir.load %{{.+}} : !cir.ptr<!cir.double>, !cir.double
+//      CHECK-AFTER:   %[[#R:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.double>, !cir.double
+// CHECK-AFTER-NEXT:   %[[#I:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.double>, !cir.double
 // CHECK-AFTER-NEXT:   %[[#C:]] = cir.complex.create %[[#R]], %[[#I]] : !cir.double -> !cir.complex<!cir.double>
 // CHECK-AFTER-NEXT:   cir.store{{.*}} %[[#C]], %{{.+}} : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
 //      CHECK-AFTER: }
@@ -107,22 +107,22 @@ void load_store() {
 
 //      CHECK-BEFORE: cir.func
 // CHECK-BEFORE-NEXT:   %[[#C2_PTR:]] = cir.get_global @c2 : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-BEFORE-NEXT:   %[[#C2:]] = cir.load %[[#C2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-BEFORE-NEXT:   %[[#C2:]] = cir.load{{.*}} %[[#C2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-BEFORE-NEXT:   %[[#C_PTR:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-BEFORE-NEXT:   cir.store{{.*}} %[[#C2]], %[[#C_PTR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-BEFORE-NEXT:   %[[#CI2_PTR:]] = cir.get_global @ci2 : !cir.ptr<!cir.complex<!s32i>>
-// CHECK-BEFORE-NEXT:   %[[#CI2:]] = cir.load %[[#CI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
+// CHECK-BEFORE-NEXT:   %[[#CI2:]] = cir.load{{.*}} %[[#CI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
 // CHECK-BEFORE-NEXT:   %[[#CI_PTR:]] = cir.get_global @ci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-BEFORE-NEXT:   cir.store{{.*}} %[[#CI2]], %[[#CI_PTR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
 // CHECK-AFTER-NEXT:   %[[#C2_PTR:]] = cir.get_global @c2 : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-AFTER-NEXT:   %[[#C2:]] = cir.load %[[#C2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-AFTER-NEXT:   %[[#C2:]] = cir.load{{.*}} %[[#C2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-AFTER-NEXT:   %[[#C_PTR:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-AFTER-NEXT:   cir.store{{.*}} %[[#C2]], %[[#C_PTR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-AFTER-NEXT:   %[[#CI2_PTR:]] = cir.get_global @ci2 : !cir.ptr<!cir.complex<!s32i>>
-// CHECK-AFTER-NEXT:   %[[#CI2:]] = cir.load %[[#CI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
+// CHECK-AFTER-NEXT:   %[[#CI2:]] = cir.load{{.*}} %[[#CI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
 // CHECK-AFTER-NEXT:   %[[#CI_PTR:]] = cir.get_global @ci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-AFTER-NEXT:   cir.store{{.*}} %[[#CI2]], %[[#CI_PTR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
 //      CHECK-AFTER: }
@@ -141,22 +141,22 @@ void load_store_volatile() {
 
 //      CHECK-BEFORE: cir.func
 // CHECK-BEFORE-NEXT:   %[[#VC2_PTR:]] = cir.get_global @vc2 : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-BEFORE-NEXT:   %[[#VC2:]] = cir.load volatile %[[#VC2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-BEFORE-NEXT:   %[[#VC2:]] = cir.load volatile{{.*}} %[[#VC2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-BEFORE-NEXT:   %[[#VC_PTR:]] = cir.get_global @vc : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-BEFORE-NEXT:   cir.store volatile{{.*}} %[[#VC2]], %[[#VC_PTR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-BEFORE-NEXT:   %[[#VCI2_PTR:]] = cir.get_global @vci2 : !cir.ptr<!cir.complex<!s32i>>
-// CHECK-BEFORE-NEXT:   %[[#VCI2:]] = cir.load volatile %[[#VCI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
+// CHECK-BEFORE-NEXT:   %[[#VCI2:]] = cir.load volatile{{.*}} %[[#VCI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
 // CHECK-BEFORE-NEXT:   %[[#VCI_PTR:]] = cir.get_global @vci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-BEFORE-NEXT:   cir.store volatile{{.*}} %[[#VCI2]], %[[#VCI_PTR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
 // CHECK-AFTER-NEXT:   %[[#VC2_PTR:]] = cir.get_global @vc2 : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-AFTER-NEXT:   %[[#VC2:]] = cir.load volatile %[[#VC2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-AFTER-NEXT:   %[[#VC2:]] = cir.load volatile{{.*}} %[[#VC2_PTR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-AFTER-NEXT:   %[[#VC_PTR:]] = cir.get_global @vc : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-AFTER-NEXT:   cir.store volatile{{.*}} %[[#VC2]], %[[#VC_PTR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-AFTER-NEXT:   %[[#VCI2_PTR:]] = cir.get_global @vci2 : !cir.ptr<!cir.complex<!s32i>>
-// CHECK-AFTER-NEXT:   %[[#VCI2:]] = cir.load volatile %[[#VCI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
+// CHECK-AFTER-NEXT:   %[[#VCI2:]] = cir.load volatile{{.*}} %[[#VCI2_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
 // CHECK-AFTER-NEXT:   %[[#VCI_PTR:]] = cir.get_global @vci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-AFTER-NEXT:   cir.store volatile{{.*}} %[[#VCI2]], %[[#VCI_PTR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
 //      CHECK-AFTER: }
@@ -174,13 +174,13 @@ void real() {
 
 //      CHECK-BEFORE: cir.func
 //      CHECK-BEFORE:   %[[#A:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-BEFORE-NEXT:   %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-BEFORE-NEXT:   %[[#B:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-BEFORE-NEXT:   %{{.+}} = cir.complex.real %[[#B]] : !cir.complex<!cir.double> -> !cir.double
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
 //      CHECK-AFTER:   %[[#A:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-AFTER-NEXT:   %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-AFTER-NEXT:   %[[#B:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-AFTER-NEXT:   %{{.+}} = cir.complex.real %[[#B]] : !cir.complex<!cir.double> -> !cir.double
 //      CHECK-AFTER: }
 
@@ -195,13 +195,13 @@ void imag() {
 
 //      CHECK-BEFORE: cir.func
 //      CHECK-BEFORE:   %[[#A:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-BEFORE-NEXT:   %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-BEFORE-NEXT:   %[[#B:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-BEFORE-NEXT:   %{{.+}} = cir.complex.imag %[[#B]] : !cir.complex<!cir.double> -> !cir.double
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
 //      CHECK-AFTER:   %[[#A:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
-// CHECK-AFTER-NEXT:   %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
+// CHECK-AFTER-NEXT:   %[[#B:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
 // CHECK-AFTER-NEXT:   %{{.+}} = cir.complex.imag %[[#B]] : !cir.complex<!cir.double> -> !cir.double
 //      CHECK-AFTER: }
 
@@ -262,19 +262,19 @@ void extract_real() {
 //      CHECK-BEFORE: cir.func
 //      CHECK-BEFORE:   %[[#C_PTR:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-BEFORE-NEXT:   %[[#REAL_PTR:]] = cir.complex.real_ptr %[[#C_PTR]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
-// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load %[[#REAL_PTR]] : !cir.ptr<!cir.double>, !cir.double
+// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load{{.*}} %[[#REAL_PTR]] : !cir.ptr<!cir.double>, !cir.double
 //      CHECK-BEFORE:   %[[#CI_PTR:]] = cir.get_global @ci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-BEFORE-NEXT:   %[[#REAL_PTR:]] = cir.complex.real_ptr %[[#CI_PTR]] : !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!s32i>
-// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load %[[#REAL_PTR]] : !cir.ptr<!s32i>, !s32i
+// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load{{.*}} %[[#REAL_PTR]] : !cir.ptr<!s32i>, !s32i
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
 //      CHECK-AFTER:   %[[#C_PTR:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-AFTER-NEXT:   %[[#REAL_PTR:]] = cir.complex.real_ptr %[[#C_PTR]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
-// CHECK-AFTER-NEXT:   %{{.+}} = cir.load %[[#REAL_PTR]] : !cir.ptr<!cir.double>, !cir.double
+// CHECK-AFTER-NEXT:   %{{.+}} = cir.load{{.*}} %[[#REAL_PTR]] : !cir.ptr<!cir.double>, !cir.double
 //      CHECK-AFTER:   %[[#CI_PTR:]] = cir.get_global @ci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-AFTER-NEXT:   %[[#REAL_PTR:]] = cir.complex.real_ptr %[[#CI_PTR]] : !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!s32i>
-// CHECK-AFTER-NEXT:   %{{.+}} = cir.load %[[#REAL_PTR]] : !cir.ptr<!s32i>, !s32i
+// CHECK-AFTER-NEXT:   %{{.+}} = cir.load{{.*}} %[[#REAL_PTR]] : !cir.ptr<!s32i>, !s32i
 //      CHECK-AFTER: }
 
 // LLVM: define dso_local void @extract_real()
@@ -315,19 +315,19 @@ void extract_imag() {
 //      CHECK-BEFORE: cir.func
 //      CHECK-BEFORE:   %[[#C_PTR:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-BEFORE-NEXT:   %[[#IMAG_PTR:]] = cir.complex.imag_ptr %[[#C_PTR]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
-// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load %[[#IMAG_PTR]] : !cir.ptr<!cir.double>, !cir.double
+// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load{{.*}} %[[#IMAG_PTR]] : !cir.ptr<!cir.double>, !cir.double
 //      CHECK-BEFORE:   %[[#CI_PTR:]] = cir.get_global @ci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-BEFORE-NEXT:   %[[#IMAG_PTR:]] = cir.complex.imag_ptr %[[#CI_PTR]] : !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!s32i>
-// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load %[[#IMAG_PTR]] : !cir.ptr<!s32i>, !s32i
+// CHECK-BEFORE-NEXT:   %{{.+}} = cir.load{{.*}} %[[#IMAG_PTR]] : !cir.ptr<!s32i>, !s32i
 //      CHECK-BEFORE: }
 
 //      CHECK-AFTER: cir.func
 //      CHECK-AFTER:   %[[#C_PTR:]] = cir.get_global @c : !cir.ptr<!cir.complex<!cir.double>>
 // CHECK-AFTER-NEXT:   %[[#IMAG_PTR:]] = cir.complex.imag_ptr %[[#C_PTR]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
-// CHECK-AFTER-NEXT:   %{{.+}} = cir.load %[[#IMAG_PTR]] : !cir.ptr<!cir.double>, !cir.double
+// CHECK-AFTER-NEXT:   %{{.+}} = cir.load{{.*}} %[[#IMAG_PTR]] : !cir.ptr<!cir.double>, !cir.double
 //      CHECK-AFTER:   %[[#CI_PTR:]] = cir.get_global @ci : !cir.ptr<!cir.complex<!s32i>>
 // CHECK-AFTER-NEXT:   %[[#IMAG_PTR:]] = cir.complex.imag_ptr %[[#CI_PTR]] : !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!s32i>
-// CHECK-AFTER-NEXT:   %{{.+}} = cir.load %[[#IMAG_PTR]] : !cir.ptr<!s32i>, !s32i
+// CHECK-AFTER-NEXT:   %{{.+}} = cir.load{{.*}} %[[#IMAG_PTR]] : !cir.ptr<!s32i>, !s32i
 //      CHECK-AFTER: }
 
 // Note: GEP emitted by cir might not be the same as LLVM, due to constant folding.
diff --git a/clang/test/CIR/CodeGen/compound-literal.c b/clang/test/CIR/CodeGen/compound-literal.c
index 3d189bcfeca4..a7a2d58e86ed 100644
--- a/clang/test/CIR/CodeGen/compound-literal.c
+++ b/clang/test/CIR/CodeGen/compound-literal.c
@@ -43,7 +43,7 @@ int foo() {
 // CIR:    cir.store{{.*}} [[ONE]], [[FIELD]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR:    cir.store{{.*}} [[ONE]], [[RET_MEM]] : !s32i, !cir.ptr<!s32i>
-// CIR:    [[RET:%.*]] = cir.load [[RET_MEM]] : !cir.ptr<!s32i>, !s32i
+// CIR:    [[RET:%.*]] = cir.load{{.*}} [[RET_MEM]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.return [[RET]] : !s32i
 
 struct G { short x, y, z; };
@@ -59,7 +59,7 @@ struct G g(int x, int y, int z) {
 // CIR:    cir.store{{.*}} {{.*}}, %[[Y]] : !s16i
 // CIR:    %[[Z:.*]] = cir.get_member %[[RETVAL]][2] {name = "z"}
 // CIR:    cir.store{{.*}} {{.*}}, %[[Z]] : !s16i
-// CIR:    %[[RES:.*]] = cir.load %[[RETVAL]]
+// CIR:    %[[RES:.*]] = cir.load{{.*}} %[[RETVAL]]
 // CIR:    cir.return %[[RES]]
 
 // Nothing meaningful to test for LLVM codegen here.
@@ -78,7 +78,7 @@ void split_large_page(unsigned long addr, pgprot_t prot)
 // CIR:   %[[VAL_4:.*]] = cir.alloca !rec_pgprot_t, !cir.ptr<!rec_pgprot_t>, ["tmp"] {alignment = 8 : i64}
 // CIR:   cir.store{{.*}} {{.*}}, %[[VAL_2]] : !u64i, !cir.ptr<!u64i>
 // CIR:   cir.store{{.*}} {{.*}}, %[[VAL_3]] : !rec_pgprot_t, !cir.ptr<!rec_pgprot_t>
-// CIR:   %[[VAL_5:.*]] = cir.load %[[VAL_2]] : !cir.ptr<!u64i>, !u64i
+// CIR:   %[[VAL_5:.*]] = cir.load{{.*}} %[[VAL_2]] : !cir.ptr<!u64i>, !u64i
 // CIR:   %[[VAL_6:.*]] = cir.cast(int_to_bool, %[[VAL_5]] : !u64i), !cir.bool
 // CIR:   cir.if %[[VAL_6]] {
 // CIR:     cir.copy %[[VAL_3]] to %[[VAL_4]] : !cir.ptr<!rec_pgprot_t>
@@ -89,7 +89,7 @@ void split_large_page(unsigned long addr, pgprot_t prot)
 // CIR:     cir.store{{.*}} %[[VAL_9]], %[[VAL_7]] : !u64i, !cir.ptr<!u64i>
 // CIR:   }
 // CIR:   %[[VAL_10:.*]] = cir.get_member %[[VAL_4]][0] {name = "pgprot"} : !cir.ptr<!rec_pgprot_t> -> !cir.ptr<!u64i>
-// CIR:   %[[VAL_11:.*]] = cir.load %[[VAL_10]] : !cir.ptr<!u64i>, !u64i
+// CIR:   %[[VAL_11:.*]] = cir.load{{.*}} %[[VAL_10]] : !cir.ptr<!u64i>, !u64i
 // CIR:   cir.return
 // CIR: }
 
diff --git a/clang/test/CIR/CodeGen/conditional-cleanup.cpp b/clang/test/CIR/CodeGen/conditional-cleanup.cpp
index 3b938c70f9ac..2397bce547e2 100644
--- a/clang/test/CIR/CodeGen/conditional-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/conditional-cleanup.cpp
@@ -66,12 +66,12 @@ namespace test7 {
 // CIR:       cir.call @_ZN5test71BC1ERKNS_1AEPS0_(%[[PTR_B0]], %[[TMP_A0]], %[[PTR_B1]]) : (!cir.ptr<![[B]]>, !cir.ptr<![[A]]>, !cir.ptr<![[B]]>) -> ()
 // CIR:     }
 // CIR:     cir.store{{.*}} %[[PTR_B0]], %[[RET_VAL]] : !cir.ptr<![[B]]>, !cir.ptr<!cir.ptr<![[B]]>>
-// CIR:     %[[DO_CLEANUP_INNER:.*]] = cir.load %[[CLEANUP_COND_INNER]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR:     %[[DO_CLEANUP_INNER:.*]] = cir.load{{.*}} %[[CLEANUP_COND_INNER]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR:     cir.if %[[DO_CLEANUP_INNER]] {
 // Dtor call: @test7::A::~A()
 // CIR:       cir.call @_ZN5test71AD1Ev(%[[TMP_A1]]) : (!cir.ptr<![[A]]>) -> ()
 // CIR:     }
-// CIR:     %[[DO_CLEANUP_OUTER:.*]] = cir.load %[[CLEANUP_COND_OUTER]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR:     %[[DO_CLEANUP_OUTER:.*]] = cir.load{{.*}} %[[CLEANUP_COND_OUTER]] : !cir.ptr<!cir.bool>, !cir.bool
 // Dtor call: @test7::A::~A()
 // CIR:     cir.if %[[DO_CLEANUP_OUTER]] {
 // CIR:       cir.call @_ZN5test71AD1Ev(%[[TMP_A0]]) : (!cir.ptr<![[A]]>) -> ()
@@ -115,7 +115,7 @@ namespace test7 {
 // CIR_EH:               cir.store{{.*}} %[[VAL_14]], %[[VAL_1]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR_EH:               cir.try synthetic cleanup {
 // CIR_EH:                 cir.call exception @_ZN5test71AC1Ev(%[[VAL_2]]) : (!cir.ptr<!rec_test73A3AA>) -> () cleanup {
-// CIR_EH:                   %[[VAL_20:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                   %[[VAL_20:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                   cir.if %[[VAL_20]] {
 // CIR_EH:                     cir.call @_ZdlPvm(%[[VAL_16]], %[[VAL_15]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                   }
@@ -135,15 +135,15 @@ namespace test7 {
 // CIR_EH:                 cir.store{{.*}} %[[VAL_10]], %[[VAL_4]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR_EH:                 cir.try synthetic cleanup {
 // CIR_EH:                   cir.call exception @_ZN5test71AC1Ev(%[[VAL_5]]) : (!cir.ptr<!rec_test73A3AA>) -> () cleanup {
-// CIR_EH:                     %[[VAL_26:.*]] = cir.load %[[VAL_4]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_26:.*]] = cir.load{{.*}} %[[VAL_4]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_26]] {
 // CIR_EH:                       cir.call @_ZdlPvm(%[[VAL_22]], %[[VAL_21]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                     }
-// CIR_EH:                     %[[VAL_27:.*]] = cir.load %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_27:.*]] = cir.load{{.*}} %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_27]] {
 // CIR_EH:                       cir.call @_ZN5test71AD1Ev(%[[VAL_2]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:                     }
-// CIR_EH:                     %[[VAL_28:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_28:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_28]] {
 // CIR_EH:                       cir.call @_ZdlPvm(%[[VAL_16]], %[[VAL_15]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                     }
@@ -157,19 +157,19 @@ namespace test7 {
 // CIR_EH:                 %[[VAL_29:.*]] = cir.const #{{.*}}<null> : !cir.ptr<!rec_test73A3AB>
 // CIR_EH:                 cir.try synthetic cleanup {
 // CIR_EH:                   cir.call exception @_ZN5test71BC1ERKNS_1AEPS0_(%[[VAL_25]], %[[VAL_5]], %[[VAL_29]]) : (!cir.ptr<!rec_test73A3AB>, !cir.ptr<!rec_test73A3AA>, !cir.ptr<!rec_test73A3AB>) -> () cleanup {
-// CIR_EH:                     %[[VAL_30:.*]] = cir.load %[[VAL_6]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_30:.*]] = cir.load{{.*}} %[[VAL_6]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_30]] {
 // CIR_EH:                       cir.call @_ZN5test71AD1Ev(%[[VAL_5]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:                     }
-// CIR_EH:                     %[[VAL_31:.*]] = cir.load %[[VAL_4]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_31:.*]] = cir.load{{.*}} %[[VAL_4]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_31]] {
 // CIR_EH:                       cir.call @_ZdlPvm(%[[VAL_22]], %[[VAL_21]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                     }
-// CIR_EH:                     %[[VAL_32:.*]] = cir.load %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_32:.*]] = cir.load{{.*}} %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_32]] {
 // CIR_EH:                       cir.call @_ZN5test71AD1Ev(%[[VAL_2]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:                     }
-// CIR_EH:                     %[[VAL_33:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                     %[[VAL_33:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                     cir.if %[[VAL_33]] {
 // CIR_EH:                       cir.call @_ZdlPvm(%[[VAL_16]], %[[VAL_15]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                     }
@@ -184,19 +184,19 @@ namespace test7 {
 // CIR_EH:               }
 // CIR_EH:               cir.try synthetic cleanup {
 // CIR_EH:                 cir.call exception @_ZN5test71BC1ERKNS_1AEPS0_(%[[VAL_19]], %[[VAL_2]], %[[VAL_25]]) : (!cir.ptr<!rec_test73A3AB>, !cir.ptr<!rec_test73A3AA>, !cir.ptr<!rec_test73A3AB>) -> () cleanup {
-// CIR_EH:                   %[[VAL_35:.*]] = cir.load %[[VAL_6]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                   %[[VAL_35:.*]] = cir.load{{.*}} %[[VAL_6]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                   cir.if %[[VAL_35]] {
 // CIR_EH:                     cir.call @_ZN5test71AD1Ev(%[[VAL_5]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:                   }
-// CIR_EH:                   %[[VAL_36:.*]] = cir.load %[[VAL_4]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                   %[[VAL_36:.*]] = cir.load{{.*}} %[[VAL_4]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                   cir.if %[[VAL_36]] {
 // CIR_EH:                     cir.call @_ZdlPvm(%[[VAL_22]], %[[VAL_21]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                   }
-// CIR_EH:                   %[[VAL_37:.*]] = cir.load %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                   %[[VAL_37:.*]] = cir.load{{.*}} %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                   cir.if %[[VAL_37]] {
 // CIR_EH:                     cir.call @_ZN5test71AD1Ev(%[[VAL_2]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:                   }
-// CIR_EH:                   %[[VAL_38:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:                   %[[VAL_38:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:                   cir.if %[[VAL_38]] {
 // CIR_EH:                     cir.call @_ZdlPvm(%[[VAL_16]], %[[VAL_15]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:                   }
@@ -210,24 +210,24 @@ namespace test7 {
 // CIR_EH:               cir.store{{.*}} %[[VAL_39]], %[[VAL_1]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR_EH:             }
 // CIR_EH:             cir.store{{.*}} %[[VAL_19]], %[[VAL_0]] : !cir.ptr<!rec_test73A3AB>, !cir.ptr<!cir.ptr<!rec_test73A3AB>>
-// CIR_EH:             %[[VAL_40:.*]] = cir.load %[[VAL_6]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:             %[[VAL_40:.*]] = cir.load{{.*}} %[[VAL_6]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:             cir.if %[[VAL_40]] {
 // CIR_EH:               cir.call @_ZN5test71AD1Ev(%[[VAL_5]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:             }
-// CIR_EH:             %[[VAL_41:.*]] = cir.load %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:             %[[VAL_41:.*]] = cir.load{{.*}} %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:             cir.if %[[VAL_41]] {
 // CIR_EH:               cir.call @_ZN5test71AD1Ev(%[[VAL_2]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:             }
-// CIR_EH:             %[[VAL_42:.*]] = cir.load %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:             %[[VAL_42:.*]] = cir.load{{.*}} %[[VAL_3]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:             cir.if %[[VAL_42]] {
 // CIR_EH:               cir.call @_ZN5test71AD1Ev(%[[VAL_2]]) : (!cir.ptr<!rec_test73A3AA>) -> ()
 // CIR_EH:             }
-// CIR_EH:             %[[VAL_43:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR_EH:             %[[VAL_43:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.bool>, !cir.bool
 // CIR_EH:             cir.if %[[VAL_43]] {
 // CIR_EH:               cir.call @_ZdlPvm(%[[VAL_16]], %[[VAL_15]]) : (!cir.ptr<!void>, !u64i) -> ()
 // CIR_EH:             }
 // CIR_EH:           }
-// CIR_EH:           %[[VAL_44:.*]] = cir.load %[[VAL_0]] : !cir.ptr<!cir.ptr<!rec_test73A3AB>>, !cir.ptr<!rec_test73A3AB>
+// CIR_EH:           %[[VAL_44:.*]] = cir.load{{.*}} %[[VAL_0]] : !cir.ptr<!cir.ptr<!rec_test73A3AB>>, !cir.ptr<!rec_test73A3AB>
 // CIR_EH:           cir.return %[[VAL_44]] : !cir.ptr<!rec_test73A3AB>
 // CIR_EH:         }
 
diff --git a/clang/test/CIR/CodeGen/const-alloca.cpp b/clang/test/CIR/CodeGen/const-alloca.cpp
index 9313b8fb5426..6df862956bcc 100644
--- a/clang/test/CIR/CodeGen/const-alloca.cpp
+++ b/clang/test/CIR/CodeGen/const-alloca.cpp
@@ -101,9 +101,9 @@ int local_scoped_const() {
 // CIR-NEXT:      %[[#init:]] = cir.call @_Z11produce_intv() : () -> !s32i
 // CIR-NEXT:      cir.store{{.*}} %[[#init]], %[[#x_slot]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT:      cir.call @_Z8blackboxRKi(%[[#x_slot]]) : (!cir.ptr<!s32i>) -> ()
-// CIR-NEXT:      %[[#x_reload:]] = cir.load %[[#x_slot]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:      %[[#x_reload:]] = cir.load{{.*}} %[[#x_slot]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:      cir.store{{.*}} %[[#x_reload]], %[[#ret_slot:]] : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT:      %[[#ret:]] = cir.load %[[#ret_slot]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:      %[[#ret:]] = cir.load{{.*}} %[[#ret_slot]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:      cir.return %[[#ret]] : !s32i
 // CIR-NEXT:    }
 //      CIR:  }
@@ -133,7 +133,7 @@ void local_const_in_loop() {
 // CIR-NEXT:          %[[#init:]] = cir.call @_Z11produce_intv() : () -> !s32i
 // CIR-NEXT:          cir.store{{.*}} %[[#init]], %[[#x_slot]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT:          cir.call @_Z8blackboxRKi(%[[#x_slot]]) : (!cir.ptr<!s32i>) -> ()
-// CIR-NEXT:          %[[#x_reload:]] = cir.load %[[#x_slot]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:          %[[#x_reload:]] = cir.load{{.*}} %[[#x_slot]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:          cir.call @_Z7consumei(%[[#x_reload]]) : (!s32i) -> ()
 // CIR-NEXT:        }
 // CIR-NEXT:        cir.yield
diff --git a/clang/test/CIR/CodeGen/copy-constructor.cpp b/clang/test/CIR/CodeGen/copy-constructor.cpp
index a7a97ea2d0c3..91defbf3efee 100644
--- a/clang/test/CIR/CodeGen/copy-constructor.cpp
+++ b/clang/test/CIR/CodeGen/copy-constructor.cpp
@@ -13,9 +13,9 @@ struct HasScalarArrayMember {
 // CIR-NEXT:    %[[#OTHER:]] = cir.alloca !cir.ptr<!rec_HasScalarArrayMember>
 // CIR-NEXT:    cir.store %arg0, %[[#THIS]]
 // CIR-NEXT:    cir.store %arg1, %[[#OTHER]]
-// CIR-NEXT:    %[[#THIS_LOAD:]] = cir.load %[[#THIS]]
+// CIR-NEXT:    %[[#THIS_LOAD:]] = cir.load{{.*}} %[[#THIS]]
 // CIR-NEXT:    %[[#THIS_ARR:]] = cir.get_member %[[#THIS_LOAD]][0] {name = "arr"}
-// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CIR-NEXT:    %[[#OTHER_ARR:]] = cir.get_member %[[#OTHER_LOAD]][0] {name = "arr"}
 // CIR-NEXT:    cir.copy %[[#OTHER_ARR]] to %[[#THIS_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 2> x 2>>
 // CIR-NEXT:    cir.return
@@ -47,31 +47,31 @@ struct ManyMembers {
 };
 
 // CIR-LABEL: cir.func linkonce_odr @_ZN11ManyMembersC2ERKS_(
-// CIR:         %[[#THIS_LOAD:]] = cir.load %[[#]]
+// CIR:         %[[#THIS_LOAD:]] = cir.load{{.*}} %[[#]]
 // CIR-NEXT:    %[[#THIS_I:]] = cir.get_member %[[#THIS_LOAD]][0] {name = "i"}
-// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER:]]
+// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER:]]
 // CIR-NEXT:    %[[#OTHER_I:]] = cir.get_member %[[#OTHER_LOAD]][0] {name = "i"}
 // CIR-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<8>
 // CIR-NEXT:    %[[#THIS_I_CAST:]] = cir.cast(bitcast, %[[#THIS_I]] : !cir.ptr<!s32i>), !cir.ptr<!void>
 // CIR-NEXT:    %[[#OTHER_I_CAST:]] = cir.cast(bitcast, %[[#OTHER_I]] : !cir.ptr<!s32i>), !cir.ptr<!void>
 // CIR-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_I_CAST]] to %[[#THIS_I_CAST]]
 // CIR-NEXT:    %[[#THIS_K:]] = cir.get_member %[[#THIS_LOAD]][2] {name = "k"}
-// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CIR-NEXT:    %[[#OTHER_K:]] = cir.get_member %[[#OTHER_LOAD]][2] {name = "k"}
 // CIR-NEXT:    cir.call @_ZN7TrivialC1ERKS_(%[[#THIS_K]], %[[#OTHER_K]])
 // CIR-NEXT:    %[[#THIS_L:]] = cir.get_member %[[#THIS_LOAD]][3] {name = "l"}
-// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CIR-NEXT:    %[[#OTHER_L:]] = cir.get_member %[[#OTHER_LOAD]][3] {name = "l"}
 // CIR-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<12>
 // CIR-NEXT:    %[[#THIS_L_CAST:]] = cir.cast(bitcast, %[[#THIS_L]] : !cir.ptr<!cir.array<!s32i x 1>>), !cir.ptr<!void>
 // CIR-NEXT:    %[[#OTHER_L_CAST:]] = cir.cast(bitcast, %[[#OTHER_L]] : !cir.ptr<!cir.array<!s32i x 1>>), !cir.ptr<!void>
 // CIR-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_L_CAST]] to %[[#THIS_L_CAST]]
 // CIR-NEXT:    %[[#THIS_N:]] = cir.get_member %[[#THIS_LOAD]][5] {name = "n"}
-// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CIR-NEXT:    %[[#OTHER_N:]] = cir.get_member %[[#OTHER_LOAD]][5] {name = "n"}
 // CIR-NEXT:    cir.call @_ZN7TrivialC1ERKS_(%[[#THIS_N]], %[[#OTHER_N]])
 // CIR-NEXT:    %[[#THIS_O:]] = cir.get_member %[[#THIS_LOAD]][6] {name = "o"}
-// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load %[[#OTHER]]
+// CIR-NEXT:    %[[#OTHER_LOAD:]] = cir.load{{.*}} %[[#OTHER]]
 // CIR-NEXT:    %[[#OTHER_O:]] = cir.get_member %[[#OTHER_LOAD]][6] {name = "o"}
 // CIR-NEXT:    %[[#MEMCPY_SIZE:]] = cir.const #cir.int<16>
 // CIR-NEXT:    %[[#THIS_O_CAST:]] = cir.cast(bitcast, %[[#THIS_O]] : !cir.ptr<!cir.ptr<!s32i>>), !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/coro-task.cpp b/clang/test/CIR/CodeGen/coro-task.cpp
index 7fb673c5ad4b..81ede133c6c8 100644
--- a/clang/test/CIR/CodeGen/coro-task.cpp
+++ b/clang/test/CIR/CodeGen/coro-task.cpp
@@ -172,7 +172,7 @@ VoidTask silly_task() {
 // CHECK:   %[[#AllocAddr:]] = cir.call @_Znwm(%[[#CoroSize]]) : (!u64i) -> !cir.ptr<!void>
 // CHECK:   cir.store{{.*}} %[[#AllocAddr]], %[[#SavedFrameAddr]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
 // CHECK: }
-// CHECK: %[[#Load0:]] = cir.load %[[#SavedFrameAddr]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CHECK: %[[#Load0:]] = cir.load{{.*}} %[[#SavedFrameAddr]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CHECK: %[[#CoroFrameAddr:]] = cir.call @__builtin_coro_begin(%[[#CoroId]], %[[#Load0]])
 
 // Call promise.get_return_object() to retrieve the task object.
@@ -220,9 +220,9 @@ VoidTask silly_task() {
 // CHECK:   }, suspend : {
 // CHECK:     %[[#FromAddrRes:]] = cir.call @_ZNSt16coroutine_handleIN5folly4coro4TaskIvE12promise_typeEE12from_addressEPv(%[[#CoroFrameAddr]])
 // CHECK:     cir.store{{.*}} %[[#FromAddrRes]], %[[#CoroHandlePromiseAddr]] : ![[CoroHandlePromise]]
-// CHECK:     %[[#CoroHandlePromiseReload:]] = cir.load %[[#CoroHandlePromiseAddr]]
+// CHECK:     %[[#CoroHandlePromiseReload:]] = cir.load{{.*}} %[[#CoroHandlePromiseAddr]]
 // CHECK:     cir.call @_ZNSt16coroutine_handleIvEC1IN5folly4coro4TaskIvE12promise_typeEEES_IT_E(%[[#CoroHandleVoidAddr]], %[[#CoroHandlePromiseReload]])
-// CHECK:     %[[#CoroHandleVoidReload:]] = cir.load %[[#CoroHandleVoidAddr]] : !cir.ptr<![[CoroHandleVoid]]>, ![[CoroHandleVoid]]
+// CHECK:     %[[#CoroHandleVoidReload:]] = cir.load{{.*}} %[[#CoroHandleVoidAddr]] : !cir.ptr<![[CoroHandleVoid]]>, ![[CoroHandleVoid]]
 // CHECK:     cir.call @_ZNSt14suspend_always13await_suspendESt16coroutine_handleIvE(%[[#SuspendAlwaysAddr]], %[[#CoroHandleVoidReload]])
 // CHECK:     cir.yield
 
@@ -265,7 +265,7 @@ VoidTask silly_task() {
 // CHECK-NEXT: %[[#CoroEndArg1:]] = cir.const #false
 // CHECK-NEXT: = cir.call @__builtin_coro_end(%[[#CoroEndArg0]], %[[#CoroEndArg1]])
 
-// CHECK: %[[#Tmp1:]] = cir.load %[[#VoidTaskAddr]]
+// CHECK: %[[#Tmp1:]] = cir.load{{.*}} %[[#VoidTaskAddr]]
 // CHECK-NEXT: cir.return %[[#Tmp1]]
 // CHECK-NEXT: }
 
@@ -328,7 +328,7 @@ folly::coro::Task<int> go1() {
 // CHECK:   %[[#ResumeVal:]] = cir.call @_ZN5folly4coro4TaskIiE12await_resumeEv(%3)
 // CHECK:   cir.store{{.*}} %[[#ResumeVal]], %[[#CoReturnValAddr]] : !s32i, !cir.ptr<!s32i>
 // CHECK: },)
-// CHECK: %[[#V:]] = cir.load %[[#CoReturnValAddr]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[#V:]] = cir.load{{.*}} %[[#CoReturnValAddr]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.call @_ZN5folly4coro4TaskIiE12promise_type12return_valueEi({{.*}}, %[[#V]])
 
 folly::coro::Task<int> go1_lambda() {
@@ -366,7 +366,7 @@ folly::coro::Task<int> go4() {
 // CHECK: cir.store{{.*}} %12, %3 : !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> ![[IntTask]]>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> ![[IntTask]]>>>
 // CHECK: cir.scope {
 // CHECK:   %17 = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp2", init] {alignment = 4 : i64}
-// CHECK:   %18 = cir.load %3 : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> ![[IntTask]]>>>, !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> ![[IntTask]]>>
+// CHECK:   %18 = cir.load{{.*}} %3 : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> ![[IntTask]]>>>, !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> ![[IntTask]]>>
 // CHECK:   %19 = cir.const #cir.int<3> : !s32i
 // CHECK:   cir.store{{.*}} %19, %17 : !s32i, !cir.ptr<!s32i>
 
@@ -400,7 +400,7 @@ folly::coro::Task<void> yield1() {
 // CHECK-NEXT:   %[[#CORO_PTR:]] = cir.alloca !rec_std3A3Acoroutine_handle3Cvoid3E, !cir.ptr<!rec_std3A3Acoroutine_handle3Cvoid3E>
 // CHECK-NEXT:   %[[#CORO2_PTR:]] = cir.alloca !rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E, !cir.ptr<!rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>
 // CHECK-NEXT:   cir.call @_ZN5folly4coro4TaskIvEC1ERKS2_(%[[#AWAITER_PTR]], %{{.+}}) : (!cir.ptr<!rec_folly3A3Acoro3A3ATask3Cvoid3E>, !cir.ptr<!rec_folly3A3Acoro3A3ATask3Cvoid3E>) -> ()
-// CHECK-NEXT:   %[[#AWAITER:]] = cir.load %[[#AWAITER_PTR]] : !cir.ptr<!rec_folly3A3Acoro3A3ATask3Cvoid3E>, !rec_folly3A3Acoro3A3ATask3Cvoid3E
+// CHECK-NEXT:   %[[#AWAITER:]] = cir.load{{.*}} %[[#AWAITER_PTR]] : !cir.ptr<!rec_folly3A3Acoro3A3ATask3Cvoid3E>, !rec_folly3A3Acoro3A3ATask3Cvoid3E
 // CHECK-NEXT:   %[[#SUSPEND:]] = cir.call @_ZN5folly4coro4TaskIvE12promise_type11yield_valueES2_(%{{.+}}, %[[#AWAITER]]) : (!cir.ptr<!rec_folly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type>, !rec_folly3A3Acoro3A3ATask3Cvoid3E) -> !rec_std3A3Asuspend_always
 // CHECK-NEXT:   cir.store{{.*}} %[[#SUSPEND]], %[[#SUSPEND_PTR]] : !rec_std3A3Asuspend_always, !cir.ptr<!rec_std3A3Asuspend_always>
 // CHECK-NEXT:   cir.await(yield, ready : {
@@ -412,9 +412,9 @@ folly::coro::Task<void> yield1() {
 // CHECK-NEXT:   }, suspend : {
 // CHECK-NEXT:     %[[#CORO2:]] = cir.call @_ZNSt16coroutine_handleIN5folly4coro4TaskIvE12promise_typeEE12from_addressEPv(%9) : (!cir.ptr<!void>) -> !rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E
 // CHECK-NEXT:     cir.store{{.*}} %[[#CORO2]], %[[#CORO2_PTR]] : !rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E, !cir.ptr<!rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>
-// CHECK-NEXT:     %[[#B:]] = cir.load %[[#CORO2_PTR]] : !cir.ptr<!rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>, !rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E
+// CHECK-NEXT:     %[[#B:]] = cir.load{{.*}} %[[#CORO2_PTR]] : !cir.ptr<!rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E>, !rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E
 // CHECK-NEXT:     cir.call @_ZNSt16coroutine_handleIvEC1IN5folly4coro4TaskIvE12promise_typeEEES_IT_E(%[[#CORO_PTR]], %[[#B]]) : (!cir.ptr<!rec_std3A3Acoroutine_handle3Cvoid3E>, !rec_std3A3Acoroutine_handle3Cfolly3A3Acoro3A3ATask3Cvoid3E3A3Apromise_type3E) -> ()
-// CHECK-NEXT:     %[[#C:]] = cir.load %[[#CORO_PTR]] : !cir.ptr<!rec_std3A3Acoroutine_handle3Cvoid3E>, !rec_std3A3Acoroutine_handle3Cvoid3E
+// CHECK-NEXT:     %[[#C:]] = cir.load{{.*}} %[[#CORO_PTR]] : !cir.ptr<!rec_std3A3Acoroutine_handle3Cvoid3E>, !rec_std3A3Acoroutine_handle3Cvoid3E
 // CHECK-NEXT:     cir.call @_ZNSt14suspend_always13await_suspendESt16coroutine_handleIvE(%[[#SUSPEND_PTR]], %[[#C]]) : (!cir.ptr<!rec_std3A3Asuspend_always>, !rec_std3A3Acoroutine_handle3Cvoid3E) -> ()
 // CHECK-NEXT:     cir.yield
 // CHECK-NEXT:   }, resume : {
diff --git a/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp b/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp
index 5316b4bf5f28..efc5ed324da2 100644
--- a/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp
+++ b/clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp
@@ -10,11 +10,11 @@ struct String {
 // CHECK:     %1 = cir.alloca !cir.ptr<!rec_String>, !cir.ptr<!cir.ptr<!rec_String>>, ["s", init, const] {alignment = 8 : i64}
 // CHECK:     cir.store{{.*}} %arg0, %0
 // CHECK:     cir.store{{.*}} %arg1, %1
-// CHECK:     %2 = cir.load %0
+// CHECK:     %2 = cir.load{{.*}} %0
 // CHECK:     %3 = cir.get_member %2[0] {name = "size"}
-// CHECK:     %4 = cir.load %1
+// CHECK:     %4 = cir.load{{.*}} %1
 // CHECK:     %5 = cir.get_member %4[0] {name = "size"}
-// CHECK:     %6 = cir.load %5 : !cir.ptr<!s64i>, !s64i
+// CHECK:     %6 = cir.load{{.*}} %5 : !cir.ptr<!s64i>, !s64i
 // CHECK:     cir.store{{.*}} %6, %3 : !s64i, !cir.ptr<!s64i>
 // CHECK:     cir.return
 // CHECK:   }
diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp
index 76050d3a0086..0cb21b069239 100644
--- a/clang/test/CIR/CodeGen/derived-to-base.cpp
+++ b/clang/test/CIR/CodeGen/derived-to-base.cpp
@@ -86,7 +86,7 @@ void C3::Layer::Initialize() {
 // CHECK:  cir.scope {
 // CHECK:    %2 = cir.base_class_addr(%1 : !cir.ptr<!rec_C33A3ALayer> nonnull) [0] -> !cir.ptr<!rec_C23A3ALayer>
 // CHECK:    %3 = cir.get_member %2[1] {name = "m_C1"} : !cir.ptr<!rec_C23A3ALayer> -> !cir.ptr<!cir.ptr<!rec_C2>>
-// CHECK:    %4 = cir.load %3 : !cir.ptr<!cir.ptr<!rec_C2>>, !cir.ptr<!rec_C2>
+// CHECK:    %4 = cir.load{{.*}} %3 : !cir.ptr<!cir.ptr<!rec_C2>>, !cir.ptr<!rec_C2>
 // CHECK:    %5 = cir.const #cir.ptr<null> : !cir.ptr<!rec_C2>
 // CHECK:    %6 = cir.cmp(eq, %4, %5) : !cir.ptr<!rec_C2>, !cir.bool
 
@@ -98,7 +98,7 @@ enumy C3::Initialize() {
 // CHECK:     %0 = cir.alloca !cir.ptr<!rec_C3>, !cir.ptr<!cir.ptr<!rec_C3>>, ["this", init] {alignment = 8 : i64}
 
 // CHECK:     cir.store %arg0, %0 : !cir.ptr<!rec_C3>, !cir.ptr<!cir.ptr<!rec_C3>>
-// CHECK:     %2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C3>>, !cir.ptr<!rec_C3>
+// CHECK:     %2 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_C3>>, !cir.ptr<!rec_C3>
 // CHECK:     %3 = cir.base_class_addr(%2 : !cir.ptr<!rec_C3> nonnull) [0] -> !cir.ptr<!rec_C2>
 // CHECK:     %4 = cir.call @_ZN2C210InitializeEv(%3) : (!cir.ptr<!rec_C2>) -> !s32i
 
@@ -114,12 +114,12 @@ void vcall(C1 &c1) {
 // CHECK:   %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["e"] {alignment = 4 : i64}
 // CHECK:   %3 = cir.alloca !rec_buffy, !cir.ptr<!rec_buffy>, ["agg.tmp0"] {alignment = 8 : i64}
 // CHECK:   cir.store %arg0, %0 : !cir.ptr<!rec_C1>, !cir.ptr<!cir.ptr<!rec_C1>>
-// CHECK:   %4 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C1>>, !cir.ptr<!rec_C1>
-// CHECK:   %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// CHECK:   %4 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_C1>>, !cir.ptr<!rec_C1>
+// CHECK:   %5 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.call @_ZN5buffyC2ERKS_(%3, %1) : (!cir.ptr<!rec_buffy>, !cir.ptr<!rec_buffy>) -> ()
-// CHECK:   %6 = cir.load %3 : !cir.ptr<!rec_buffy>, !rec_buffy
+// CHECK:   %6 = cir.load{{.*}} %3 : !cir.ptr<!rec_buffy>, !rec_buffy
 // CHECK:   %7 = cir.cast(bitcast, %4 : !cir.ptr<!rec_C1>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>>
-// CHECK:   %8 = cir.load %7 : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>
+// CHECK:   %8 = cir.load{{.*}} %7 : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>
 // CHECK:   %9 = cir.vtable.address_point( %8 : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>, address_point = <index = 0, offset = 2>) : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>
 // CHECK:   %10 = cir.load align(8) %9 : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>>, !cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>
 // CHECK:   %11 = cir.call %10(%4, %5, %6) : (!cir.ptr<!cir.func<(!cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i>>, !cir.ptr<!rec_C1>, !s32i, !rec_buffy) -> !s32i
@@ -141,7 +141,7 @@ class B : public A {
 // CHECK: cir.func linkonce_odr @_ZN1B3fooEv(%arg0: !cir.ptr<!rec_B>
 // CHECK:   %0 = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["this", init] {alignment = 8 : i64}
 // CHECK:   cir.store %arg0, %0 : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
-// CHECK:   %1 = cir.load deref %0 : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
+// CHECK:   %1 = cir.load{{.*}} deref %0 : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
 // CHECK:   cir.scope {
 // CHECK:     %2 = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["ref.tmp0"] {alignment = 8 : i64}
 // CHECK:     %3 = cir.base_class_addr(%1 : !cir.ptr<!rec_B> nonnull) [0] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp
index 0466b9881822..c89caf32a7a6 100644
--- a/clang/test/CIR/CodeGen/dtors.cpp
+++ b/clang/test/CIR/CodeGen/dtors.cpp
@@ -87,7 +87,7 @@ bool bar() { return foo(1) || foo(2); }
 // CHECK:     cir.store %[[V5]], %[[V0]] : !cir.bool, !cir.ptr<!cir.bool>
 // CHECK:     cir.call @_ZN1XD2Ev(%[[V2]]) : (!cir.ptr<!rec_X>) -> ()
 // CHECK:   }
-// CHECK:   %[[V1:.*]] = cir.load %[[V0]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:   %[[V1:.*]] = cir.load{{.*}} %[[V0]] : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK:   cir.return %[[V1]] : !cir.bool
 // CHECK: }
 
@@ -125,7 +125,7 @@ bool bar2() { return foo(1) && foo(2); }
 // CHECK:   cir.func linkonce_odr @_ZN1BD0Ev(%arg0: !cir.ptr<![[ClassB]]>
 // CHECK:     %0 = cir.alloca !cir.ptr<![[ClassB]]>, !cir.ptr<!cir.ptr<![[ClassB]]>>, ["this", init] {alignment = 8 : i64}
 // CHECK:     cir.store %arg0, %0 : !cir.ptr<![[ClassB]]>, !cir.ptr<!cir.ptr<![[ClassB]]>>
-// CHECK:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<![[ClassB]]>>, !cir.ptr<![[ClassB]]>
+// CHECK:     %1 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<![[ClassB]]>>, !cir.ptr<![[ClassB]]>
 // CHECK:     cir.call @_ZN1BD2Ev(%1) : (!cir.ptr<![[ClassB]]>) -> ()
 // CHECK:     %2 = cir.cast(bitcast, %1 : !cir.ptr<![[ClassB]]>), !cir.ptr<!void>
 // CHECK:     cir.call @_ZdlPvm(%2, %3) : (!cir.ptr<!void>, !u64i) -> ()
@@ -167,11 +167,11 @@ void m() { G l(j); }
 // CHECK:   %[[V0:.*]] = cir.alloca !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>, ["this", init] {alignment = 8 : i64}
 // CHECK:   %[[V1:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["__retval"] {alignment = 8 : i64}
 // CHECK:   cir.store %arg0, %[[V0]] : !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>
-// CHECK:   %[[V2:.*]] = cir.load %[[V0]] : !cir.ptr<!cir.ptr<!rec_G>>, !cir.ptr<!rec_G>
+// CHECK:   %[[V2:.*]] = cir.load{{.*}} %[[V0]] : !cir.ptr<!cir.ptr<!rec_G>>, !cir.ptr<!rec_G>
 // CHECK:   %[[V3:.*]] = cir.scope {
 // CHECK:     %[[V4:.*]] = cir.alloca !rec_A2, !cir.ptr<!rec_A2>, ["agg.tmp0"] {alignment = 1 : i64}
 // CHECK:     cir.call @_ZN2A2C2Ev(%[[V4]]) : (!cir.ptr<!rec_A2>) -> ()
-// CHECK:     %[[V5:.*]] = cir.load %[[V4]] : !cir.ptr<!rec_A2>, !rec_A2
+// CHECK:     %[[V5:.*]] = cir.load{{.*}} %[[V4]] : !cir.ptr<!rec_A2>, !rec_A2
 // CHECK:     %[[V6:.*]] = cir.call @_ZN1G1kE2A2(%[[V2]], %[[V5]]) : (!cir.ptr<!rec_G>, !rec_A2) -> !s64i
 // CHECK:     cir.call @_ZN2A2D1Ev(%[[V4]]) : (!cir.ptr<!rec_A2>) -> ()
 // CHECK:     cir.yield %[[V6]] : !s64i
diff --git a/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp b/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
index a53f2ebe714f..ba2b56ebf2ea 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
@@ -15,10 +15,10 @@ struct Derived final : Base1 {};
 
 Derived *ptr_cast(Base1 *ptr) {
   return dynamic_cast<Derived *>(ptr);
-  //      CHECK: %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base1>>, !cir.ptr<!rec_Base1>
+  //      CHECK: %[[#SRC:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base1>>, !cir.ptr<!rec_Base1>
   // CHECK-NEXT: %[[#EXPECTED_VPTR:]] = cir.vtable.address_point(@_ZTV7Derived, address_point = <index = 0, offset = 2>) : !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>
   // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>>
-  // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>>, !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>
+  // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load{{.*}} %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>>, !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>
   // CHECK-NEXT: %[[#SUCCESS:]] = cir.cmp(eq, %[[#SRC_VPTR]], %[[#EXPECTED_VPTR]]) : !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>, !cir.bool
   // CHECK-NEXT: %{{.+}} = cir.ternary(%[[#SUCCESS]], true {
   // CHECK-NEXT:   %[[#RES:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!rec_Derived>
@@ -38,10 +38,10 @@ Derived *ptr_cast(Base1 *ptr) {
 
 Derived &ref_cast(Base1 &ref) {
   return dynamic_cast<Derived &>(ref);
-  //      CHECK: %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base1>>, !cir.ptr<!rec_Base1>
+  //      CHECK: %[[#SRC:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base1>>, !cir.ptr<!rec_Base1>
   // CHECK-NEXT: %[[#EXPECTED_VPTR:]] = cir.vtable.address_point(@_ZTV7Derived, address_point = <index = 0, offset = 2>) : !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>
   // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>>
-  // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>>, !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>
+  // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load{{.*}} %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>>, !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>
   // CHECK-NEXT: %[[#SUCCESS:]] = cir.cmp(eq, %[[#SRC_VPTR]], %[[#EXPECTED_VPTR]]) : !cir.ptr<!cir.ptr<!cir.func<() -> !u32i>>>, !cir.bool
   // CHECK-NEXT: %[[#FAILED:]] = cir.unary(not, %[[#SUCCESS]]) : !cir.bool, !cir.bool
   // CHECK-NEXT: cir.if %[[#FAILED]] {
@@ -64,7 +64,7 @@ Derived &ref_cast(Base1 &ref) {
 
 Derived *ptr_cast_always_fail(Base2 *ptr) {
   return dynamic_cast<Derived *>(ptr);
-  //      CHECK: %{{.+}} = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base2>>, !cir.ptr<!rec_Base2>
+  //      CHECK: %{{.+}} = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base2>>, !cir.ptr<!rec_Base2>
   // CHECK-NEXT: %[[#RESULT:]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_Derived>
   // CHECK-NEXT: cir.store %[[#RESULT]], %{{.+}} : !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>
 }
@@ -75,7 +75,7 @@ Derived *ptr_cast_always_fail(Base2 *ptr) {
 
 Derived &ref_cast_always_fail(Base2 &ref) {
   return dynamic_cast<Derived &>(ref);
-  //      CHECK: %{{.+}} = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base2>>, !cir.ptr<!rec_Base2>
+  //      CHECK: %{{.+}} = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base2>>, !cir.ptr<!rec_Base2>
   // CHECK-NEXT: %{{.+}} = cir.const #cir.ptr<null> : !cir.ptr<!rec_Derived>
   // CHECK-NEXT: cir.call @__cxa_bad_cast() : () -> ()
   // CHECK-NEXT: cir.unreachable
diff --git a/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp b/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
index 8b2c18876ef0..24879c45c366 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
@@ -16,11 +16,11 @@ void *ptr_cast_to_complete(Base *ptr) {
 // BEFORE: }
 
 //      AFTER: cir.func @_Z20ptr_cast_to_completeP4Base
-//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base>
+//      AFTER:   %[[#SRC:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base>
 // AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.bool
 // AFTER-NEXT:   %{{.+}} = cir.ternary(%[[#SRC_IS_NOT_NULL]], true {
 // AFTER-NEXT:     %[[#VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.ptr<!cir.ptr<!s32i>>
-// AFTER-NEXT:     %[[#VPTR:]] = cir.load %[[#VPTR_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// AFTER-NEXT:     %[[#VPTR:]] = cir.load{{.*}} %[[#VPTR_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // AFTER-NEXT:     %[[#OFFSET_TO_TOP_PTR:]] = cir.vtable.address_point( %[[#VPTR]] : !cir.ptr<!s32i>,  address_point = <index = 0, offset = -2>) : !cir.ptr<!s32i>
 // AFTER-NEXT:     %[[#OFFSET_TO_TOP:]] = cir.load align(4) %[[#OFFSET_TO_TOP_PTR]] : !cir.ptr<!s32i>, !s32i
 // AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGen/dynamic-cast.cpp b/clang/test/CIR/CodeGen/dynamic-cast.cpp
index d010636a622f..4bacf2281893 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast.cpp
@@ -20,7 +20,7 @@ Derived *ptr_cast(Base *b) {
 // BEFORE: }
 
 //      AFTER: cir.func @_Z8ptr_castP4Base
-//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base>
+//      AFTER:   %[[#SRC:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base>
 // AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.bool
 // AFTER-NEXT:   %{{.+}} = cir.ternary(%[[#SRC_IS_NOT_NULL]], true {
 // AFTER-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.ptr<!void>
@@ -68,11 +68,11 @@ void *ptr_cast_to_complete(Base *ptr) {
 // BEFORE: }
 
 //      AFTER: cir.func @_Z20ptr_cast_to_completeP4Base
-//      AFTER:   %[[#SRC:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base>
+//      AFTER:   %[[#SRC:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base>
 // AFTER-NEXT:   %[[#SRC_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.bool
 // AFTER-NEXT:   %{{.+}} = cir.ternary(%[[#SRC_IS_NOT_NULL]], true {
 // AFTER-NEXT:     %[[#VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.ptr<!cir.ptr<!s64i>>
-// AFTER-NEXT:     %[[#VPTR:]] = cir.load %[[#VPTR_PTR]] : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+// AFTER-NEXT:     %[[#VPTR:]] = cir.load{{.*}} %[[#VPTR_PTR]] : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
 // AFTER-NEXT:     %[[#BASE_OFFSET_PTR:]] = cir.vtable.address_point( %[[#VPTR]] : !cir.ptr<!s64i>, address_point = <index = 0, offset = -2>) : !cir.ptr<!s64i>
 // AFTER-NEXT:     %[[#BASE_OFFSET:]] = cir.load align(8) %[[#BASE_OFFSET_PTR]] : !cir.ptr<!s64i>, !s64i
 // AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base>), !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGen/forward-decls.cpp b/clang/test/CIR/CodeGen/forward-decls.cpp
index 34eecb8d1ab8..059ef9c6e860 100644
--- a/clang/test/CIR/CodeGen/forward-decls.cpp
+++ b/clang/test/CIR/CodeGen/forward-decls.cpp
@@ -50,7 +50,7 @@ struct RecursiveStruct {
 // CHECK3: testRecursiveStruct(%arg0: !cir.ptr<![[STRUCT]]>
 void testRecursiveStruct(struct RecursiveStruct *arg) {
   // CHECK3: %[[#NEXT:]] = cir.get_member %{{.+}}[1] {name = "next"} : !cir.ptr<![[STRUCT]]> -> !cir.ptr<!cir.ptr<![[STRUCT]]>>
-  // CHECK3: %[[#DEREF:]] = cir.load %[[#NEXT]] : !cir.ptr<!cir.ptr<![[STRUCT]]>>, !cir.ptr<![[STRUCT]]>
+  // CHECK3: %[[#DEREF:]] = cir.load{{.*}} %[[#NEXT]] : !cir.ptr<!cir.ptr<![[STRUCT]]>>, !cir.ptr<![[STRUCT]]>
   // CHECK3: cir.get_member %[[#DEREF]][0] {name = "value"} : !cir.ptr<![[STRUCT]]> -> !cir.ptr<!s32i>
   arg->next->value;
 }
@@ -81,9 +81,9 @@ struct StructNodeB {
 
 void testIndirectSelfReference(struct StructNodeA arg) {
   // CHECK4: %[[#V1:]] = cir.get_member %{{.+}}[1] {name = "next"} : !cir.ptr<![[A]]> -> !cir.ptr<!cir.ptr<![[B]]>>
-  // CHECK4: %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!cir.ptr<![[B]]>>, !cir.ptr<![[B]]>
+  // CHECK4: %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!cir.ptr<![[B]]>>, !cir.ptr<![[B]]>
   // CHECK4: %[[#V3:]] = cir.get_member %[[#V2]][1] {name = "next"} : !cir.ptr<![[B]]> -> !cir.ptr<!cir.ptr<![[A]]>>
-  // CHECK4: %[[#V4:]] = cir.load %[[#V3]] : !cir.ptr<!cir.ptr<![[A]]>>, !cir.ptr<![[A]]>
+  // CHECK4: %[[#V4:]] = cir.load{{.*}} %[[#V3]] : !cir.ptr<!cir.ptr<![[A]]>>, !cir.ptr<![[A]]>
   // CHECK4: cir.get_member %[[#V4]][0] {name = "value"} : !cir.ptr<![[A]]> -> !cir.ptr<!s32i>
   arg.next->next->value;
 }
diff --git a/clang/test/CIR/CodeGen/fun-ptr.c b/clang/test/CIR/CodeGen/fun-ptr.c
index 669481259c1e..cc842226982d 100644
--- a/clang/test/CIR/CodeGen/fun-ptr.c
+++ b/clang/test/CIR/CodeGen/fun-ptr.c
@@ -33,8 +33,8 @@ int extract_a(Data* d) {
 // CIR:   cir.store{{.*}} [[TMP3]], [[TMP2]] : !cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>>
 // CIR:   [[TMP4:%.*]] = cir.get_global {{@.*extract_a.*}} : !cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>
 // CIR:   cir.store{{.*}} [[TMP4]], [[TMP2]] : !cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>>
-// CIR:   [[TMP5:%.*]] = cir.load [[TMP2]] : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>>, !cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>
-// CIR:   [[TMP6:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
+// CIR:   [[TMP5:%.*]] = cir.load{{.*}} [[TMP2]] : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>>, !cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>
+// CIR:   [[TMP6:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
 // CIR:   [[TMP7:%.*]] = cir.call [[TMP5]]([[TMP6]]) : (!cir.ptr<!cir.func<(!cir.ptr<!rec_Data>) -> !s32i>>, !cir.ptr<!rec_Data>) -> !s32i
 // CIR:   cir.store{{.*}} [[TMP7]], [[TMP1]] : !s32i, !cir.ptr<!s32i>
 
diff --git a/clang/test/CIR/CodeGen/globals.cpp b/clang/test/CIR/CodeGen/globals.cpp
index 1bf197c2f172..987d3267fe97 100644
--- a/clang/test/CIR/CodeGen/globals.cpp
+++ b/clang/test/CIR/CodeGen/globals.cpp
@@ -43,7 +43,7 @@ int use_func() { return func<int>(); }
 // CHECK-NEXT: cir.func internal private @__cxx_global_var_init()
 // CHECK-NEXT:   [[TMP0:%.*]] = cir.get_global @d : !cir.ptr<!s32i>
 // CHECK-NEXT:   [[TMP1:%.*]] = cir.get_global @a : !cir.ptr<!s32i>
-// CHECK-NEXT:   [[TMP2:%.*]] = cir.load [[TMP1]] : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   [[TMP2:%.*]] = cir.load{{.*}} [[TMP1]] : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   cir.store{{.*}} [[TMP2]], [[TMP0]] : !s32i, !cir.ptr<!s32i>
 
 // CHECK: cir.global external @e = #false
@@ -64,16 +64,16 @@ int use_func() { return func<int>(); }
 //      CHECK: cir.func @_Z10use_globalv()
 // CHECK-NEXT:     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["li", init] {alignment = 4 : i64}
 // CHECK-NEXT:     %1 = cir.get_global @a : !cir.ptr<!s32i>
-// CHECK-NEXT:     %2 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:     %2 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:     cir.store{{.*}} %2, %0 : !s32i, !cir.ptr<!s32i>
 
 //      CHECK: cir.func @_Z17use_global_stringv()
 // CHECK-NEXT:   %0 = cir.alloca !u8i, !cir.ptr<!u8i>, ["c", init] {alignment = 1 : i64}
 // CHECK-NEXT:   %1 = cir.get_global @s2 : !cir.ptr<!cir.ptr<!s8i>>
-// CHECK-NEXT:   %2 = cir.load %1 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+// CHECK-NEXT:   %2 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
 // CHECK-NEXT:   %3 = cir.const #cir.int<0> : !s32i
 // CHECK-NEXT:   %4 = cir.ptr_stride(%2 : !cir.ptr<!s8i>, %3 : !s32i), !cir.ptr<!s8i>
-// CHECK-NEXT:   %5 = cir.load %4 : !cir.ptr<!s8i>, !s8i
+// CHECK-NEXT:   %5 = cir.load{{.*}} %4 : !cir.ptr<!s8i>, !s8i
 // CHECK-NEXT:   %6 = cir.cast(integral, %5 : !s8i), !u8i
 // CHECK-NEXT:   cir.store{{.*}} %6, %0 : !u8i, !cir.ptr<!u8i>
 // CHECK-NEXT:   cir.return
@@ -82,14 +82,14 @@ int use_func() { return func<int>(); }
 // CHECK-NEXT:    %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK-NEXT:    %1 = cir.const #cir.int<0> : !s32i
 // CHECK-NEXT:    cir.store{{.*}} %1, %0 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:    %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:    %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:    cir.return %2 : !s32i
 // CHECK-NEXT:  }
 // CHECK-NEXT:  cir.func @_Z8use_funcv() -> !s32i
 // CHECK-NEXT:    %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK-NEXT:    %1 = cir.call @_Z4funcIiET_v() : () -> !s32i
 // CHECK-NEXT:    cir.store{{.*}} %1, %0 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:    %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:    %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:    cir.return %2 : !s32i
 // CHECK-NEXT:  }
 
diff --git a/clang/test/CIR/CodeGen/if-constexpr.cpp b/clang/test/CIR/CodeGen/if-constexpr.cpp
index ab628aee8195..a03ac6f42c4b 100644
--- a/clang/test/CIR/CodeGen/if-constexpr.cpp
+++ b/clang/test/CIR/CodeGen/if-constexpr.cpp
@@ -56,7 +56,7 @@ void if0() {
 // CHECK-NEXT:   %3 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {{.*}}
 // CHECK-NEXT:   %4 = cir.const #cir.int<7> : !s32i loc({{.*}})
 // CHECK-NEXT:   cir.store{{.*}} %4, %2 : !s32i, !cir.ptr<!s32i> loc({{.*}})
-// CHECK-NEXT:   %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
+// CHECK-NEXT:   %5 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
 // CHECK-NEXT:   cir.store{{.*}} %5, %3 : !s32i, !cir.ptr<!s32i> loc({{.*}})
 // CHECK-NEXT: } loc({{.*}})
 // CHECK-NEXT: cir.scope {
@@ -65,7 +65,7 @@ void if0() {
 // CHECK-NEXT:   %4 = cir.const #cir.int<9> : !s32i loc({{.*}})
 // CHECK-NEXT:   cir.store{{.*}} %4, %2 : !s32i, !cir.ptr<!s32i> loc({{.*}})
 // CHECK-NEXT:   %5 = cir.const #cir.int<3> : !s32i loc({{.*}})
-// CHECK-NEXT:   %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
+// CHECK-NEXT:   %6 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
 // CHECK-NEXT:   %7 = cir.binop(mul, %5, %6) nsw : !s32i loc({{.*}})
 // CHECK-NEXT:   cir.store{{.*}} %7, %3 : !s32i, !cir.ptr<!s32i> loc({{.*}})
 // CHECK-NEXT: } loc({{.*}})
@@ -80,7 +80,7 @@ void if0() {
 // CHECK-NEXT:   %4 = cir.const #cir.int<70> : !s32i loc({{.*}})
 // CHECK-NEXT:   cir.store{{.*}} %4, %2 : !s32i, !cir.ptr<!s32i> loc({{.*}})
 // CHECK-NEXT:   %5 = cir.const #cir.int<10> : !s32i loc({{.*}})
-// CHECK-NEXT:   %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
+// CHECK-NEXT:   %6 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
 // CHECK-NEXT:   %7 = cir.binop(mul, %5, %6) nsw : !s32i loc({{.*}})
 // CHECK-NEXT:   cir.store{{.*}} %7, %3 : !s32i, !cir.ptr<!s32i> loc({{.*}})
 // CHECK-NEXT: } loc({{.*}})
diff --git a/clang/test/CIR/CodeGen/inc-bool.cpp b/clang/test/CIR/CodeGen/inc-bool.cpp
index 9a3c9f429a42..1c9b9dee920c 100644
--- a/clang/test/CIR/CodeGen/inc-bool.cpp
+++ b/clang/test/CIR/CodeGen/inc-bool.cpp
@@ -8,7 +8,7 @@ void foo(bool x) {
 // CHECK:  cir.func @_Z3foob(%arg0: !cir.bool loc({{.*}}))
 // CHECK:    [[ALLOC_X:%.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
 // CHECK:    cir.store{{.*}} %arg0, [[ALLOC_X]] : !cir.bool, !cir.ptr<!cir.bool>
-// CHECK:    {{.*}} = cir.load [[ALLOC_X]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:    {{.*}} = cir.load{{.*}} [[ALLOC_X]] : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK:    [[TRUE:%.*]] = cir.const #true
 // CHECK:    cir.store{{.*}} [[TRUE]], [[ALLOC_X]] : !cir.bool, !cir.ptr<!cir.bool>
 // CHECK:    cir.return
diff --git a/clang/test/CIR/CodeGen/inc-dec.cpp b/clang/test/CIR/CodeGen/inc-dec.cpp
index 5c7ff312542a..129b91c8e340 100644
--- a/clang/test/CIR/CodeGen/inc-dec.cpp
+++ b/clang/test/CIR/CodeGen/inc-dec.cpp
@@ -9,7 +9,7 @@ unsigned id0() {
 // CHECK: cir.func @_Z3id0v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#BEFORE_A:]] = cir.load %[[#A]]
+// CHECK: %[[#BEFORE_A:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#AFTER_A:]] = cir.unary(inc, %[[#BEFORE_A]])
 // CHECK: cir.store{{.*}} %[[#AFTER_A]], %[[#A]]
 // CHECK: cir.store{{.*}} %[[#AFTER_A]], %[[#RET]]
@@ -23,7 +23,7 @@ unsigned id1() {
 // CHECK: cir.func @_Z3id1v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#BEFORE_A:]] = cir.load %[[#A]]
+// CHECK: %[[#BEFORE_A:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#AFTER_A:]] = cir.unary(dec, %[[#BEFORE_A]])
 // CHECK: cir.store{{.*}} %[[#AFTER_A]], %[[#A]]
 // CHECK: cir.store{{.*}} %[[#AFTER_A]], %[[#RET]]
@@ -36,7 +36,7 @@ unsigned id2() {
 // CHECK: cir.func @_Z3id2v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#BEFORE_A:]] = cir.load %[[#A]]
+// CHECK: %[[#BEFORE_A:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#AFTER_A:]] = cir.unary(inc, %[[#BEFORE_A]])
 // CHECK: cir.store{{.*}} %[[#AFTER_A]], %[[#A]]
 // CHECK: cir.store{{.*}} %[[#BEFORE_A]], %[[#RET]]
@@ -49,7 +49,7 @@ unsigned id3() {
 // CHECK: cir.func @_Z3id3v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#BEFORE_A:]] = cir.load %[[#A]]
+// CHECK: %[[#BEFORE_A:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#AFTER_A:]] = cir.unary(dec, %[[#BEFORE_A]])
 // CHECK: cir.store{{.*}} %[[#AFTER_A]], %[[#A]]
 // CHECK: cir.store{{.*}} %[[#BEFORE_A]], %[[#RET]]
diff --git a/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp b/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp
index 8cf4b9b304f3..96a1fcb47f79 100644
--- a/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp
+++ b/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp
@@ -45,7 +45,7 @@ void test() {
 // CIR: [[LOCAL_ELEM_ARRAY_END:%.*]] = cir.ptr_stride([[LOCAL_ELEM_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, [[ELEM_ARRAY_LEN]] : !u64i), !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>
 // CIR: [[END_FLD_PTR_AS_PTR_2_CHAR_ARRAY:%.*]] = cir.cast(bitcast, [[END_FLD_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>), !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
 // CIR: cir.store{{.*}} [[LOCAL_ELEM_ARRAY_END]], [[END_FLD_PTR_AS_PTR_2_CHAR_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
-// CIR: [[ARG:%.*]] = cir.load [[INITLIST_LOCAL]] : !cir.ptr<[[INITLIST_TYPE]]>, [[INITLIST_TYPE]]
+// CIR: [[ARG:%.*]] = cir.load{{.*}} [[INITLIST_LOCAL]] : !cir.ptr<[[INITLIST_TYPE]]>, [[INITLIST_TYPE]]
 // CIR: cir.call @_ZSt1fIPKcEvSt16initializer_listIT_E([[ARG]]) : ([[INITLIST_TYPE]]) -> ()
 // CIR: }
 // CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp b/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp
index 86920aff270c..c70fb4ce6ac9 100644
--- a/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp
+++ b/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp
@@ -35,7 +35,7 @@ void test() {
 // CIR: [[LENGTH_ONE:%.*]] = cir.const #cir.int<1>
 // CIR: [[FLD_LEN:%.*]] = cir.get_member [[LIST_PTR]][1] {name = "len"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} [[LENGTH_ONE]], [[FLD_LEN]] : !u64i, !cir.ptr<!u64i>
-// CIR: [[ARG2PASS:%.*]] = cir.load [[LIST_PTR]] : !cir.ptr<[[INITLIST_TYPE]]>,  [[INITLIST_TYPE]]
+// CIR: [[ARG2PASS:%.*]] = cir.load{{.*}} [[LIST_PTR]] : !cir.ptr<[[INITLIST_TYPE]]>,  [[INITLIST_TYPE]]
 // CIR: cir.call @_ZSt1fIiEvSt16initializer_listIT_E([[ARG2PASS]]) : ([[INITLIST_TYPE]]) -> ()
 // CIR: }
 // CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/lalg.c b/clang/test/CIR/CodeGen/lalg.c
index 67148b8677bc..7a086e9d059d 100644
--- a/clang/test/CIR/CodeGen/lalg.c
+++ b/clang/test/CIR/CodeGen/lalg.c
@@ -15,6 +15,6 @@ double dot() {
 // CHECK-NEXT: %5 = cir.const #cir.fp<0.000000e+00> : !cir.float
 // CHECK-NEXT: %6 = cir.cast(floating, %5 : !cir.float), !cir.double
 // CHECK-NEXT: cir.store{{.*}} %6, %2 : !cir.double, !cir.ptr<!cir.double>
-// CHECK-NEXT: %7 = cir.load %1 : !cir.ptr<!cir.double>, !cir.double
-// CHECK-NEXT: %8 = cir.load %2 : !cir.ptr<!cir.double>, !cir.double
+// CHECK-NEXT: %7 = cir.load{{.*}} %1 : !cir.ptr<!cir.double>, !cir.double
+// CHECK-NEXT: %8 = cir.load{{.*}} %2 : !cir.ptr<!cir.double>, !cir.double
 // CHECK-NEXT: %9 = cir.binop(mul, %7, %8) : !cir.double
diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp
index d900d304ebe8..7abc899f6f36 100644
--- a/clang/test/CIR/CodeGen/lambda.cpp
+++ b/clang/test/CIR/CodeGen/lambda.cpp
@@ -45,14 +45,14 @@ void l0() {
 
 // CHECK: %0 = cir.alloca !cir.ptr<!rec_anon2E2>, !cir.ptr<!cir.ptr<!rec_anon2E2>>, ["this", init] {alignment = 8 : i64}
 // CHECK: cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_anon2E2>, !cir.ptr<!cir.ptr<!rec_anon2E2>>
-// CHECK: %1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_anon2E2>>, !cir.ptr<!rec_anon2E2>
+// CHECK: %1 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_anon2E2>>, !cir.ptr<!rec_anon2E2>
 // CHECK: %2 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!rec_anon2E2> -> !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %3 = cir.load %2 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK: %4 = cir.load %3 : !cir.ptr<!s32i>, !s32i
+// CHECK: %3 = cir.load{{.*}} %2 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %4 = cir.load{{.*}} %3 : !cir.ptr<!s32i>, !s32i
 // CHECK: %5 = cir.const #cir.int<1> : !s32i
 // CHECK: %6 = cir.binop(add, %4, %5) nsw : !s32i
 // CHECK: %7 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!rec_anon2E2> -> !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %8 = cir.load %7 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK: %8 = cir.load{{.*}} %7 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK: cir.store{{.*}} %6, %8 : !s32i, !cir.ptr<!s32i>
 
 // CHECK-LABEL: _Z2l0v
@@ -101,7 +101,7 @@ auto g() {
 // CHECK: cir.store{{.*}} %2, %1 : !s32i, !cir.ptr<!s32i>
 // CHECK: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr<!rec_anon2E3> -> !cir.ptr<!cir.ptr<!s32i>>
 // CHECK: cir.store{{.*}} %1, %3 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %4 = cir.load %0 : !cir.ptr<!rec_anon2E3>, !rec_anon2E3
+// CHECK: %4 = cir.load{{.*}} %0 : !cir.ptr<!rec_anon2E3>, !rec_anon2E3
 // CHECK: cir.return %4 : !rec_anon2E3
 
 // LLVM-LABEL: @_Z1gv()
@@ -130,7 +130,7 @@ auto g2() {
 // CHECK-NEXT: cir.store{{.*}} %2, %1 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr<!rec_anon2E4> -> !cir.ptr<!cir.ptr<!s32i>>
 // CHECK-NEXT: cir.store{{.*}} %1, %3 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CHECK-NEXT: %4 = cir.load %0 : !cir.ptr<!rec_anon2E4>, !rec_anon2E4
+// CHECK-NEXT: %4 = cir.load{{.*}} %0 : !cir.ptr<!rec_anon2E4>, !rec_anon2E4
 // CHECK-NEXT: cir.return %4 : !rec_anon2E4
 
 // LLVM-LABEL: @_Z2g2v()
@@ -155,7 +155,7 @@ int f() {
 // CHECK-NEXT:     %4 = cir.call @_ZZ2g2vENK3$_0clEv(%2) : (!cir.ptr<!rec_anon2E4>) -> !s32i
 // CHECK-NEXT:     cir.store{{.*}} %4, %0 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:   }
-// CHECK-NEXT:   %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %1 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   cir.return %1 : !s32i
 // CHECK-NEXT: }
 
@@ -222,7 +222,7 @@ int g3() {
 // CHECK:     cir.store{{.*}} %3, %1 : !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
 // CHECK:     %4 = cir.scope {
 // CHECK:       %7 = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp1", init] {alignment = 4 : i64}
-// CHECK:       %8 = cir.load %1 : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>, !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>
+// CHECK:       %8 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>, !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>
 // CHECK:       %9 = cir.const #cir.int<3> : !s32i
 // CHECK:       cir.store{{.*}} %9, %7 : !s32i, !cir.ptr<!s32i>
 
@@ -304,12 +304,12 @@ struct A {
 // CHECK: [[ARG_ADDR:%.*]] = cir.alloca !cir.ptr<!rec_anon2E7>, !cir.ptr<!cir.ptr<!rec_anon2E7>>, ["this", init] {alignment = 8 : i64}
 // CHECK: [[RETVAL_ADDR:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK: cir.store{{.*}} [[ARG]], [[ARG_ADDR]] : !cir.ptr<!rec_anon2E7>, !cir.ptr<!cir.ptr<!rec_anon2E7>>
-// CHECK: [[CLS_ANNO7:%.*]] = cir.load [[ARG_ADDR]] : !cir.ptr<!cir.ptr<!rec_anon2E7>>, !cir.ptr<!rec_anon2E7>
+// CHECK: [[CLS_ANNO7:%.*]] = cir.load{{.*}} [[ARG_ADDR]] : !cir.ptr<!cir.ptr<!rec_anon2E7>>, !cir.ptr<!rec_anon2E7>
 // CHECK: [[STRUCT_A:%.*]] = cir.get_member [[CLS_ANNO7]][0] {name = "this"} : !cir.ptr<!rec_anon2E7> -> !cir.ptr<!rec_A>
 // CHECK: [[a:%.*]] = cir.get_member [[STRUCT_A]][0] {name = "a"} : !cir.ptr<!rec_A> -> !cir.ptr<!s32i> loc(#loc70)
-// CHECK: [[TMP0:%.*]] = cir.load [[a]] : !cir.ptr<!s32i>, !s32i
+// CHECK: [[TMP0:%.*]] = cir.load{{.*}} [[a]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} [[TMP0]], [[RETVAL_ADDR]] : !s32i, !cir.ptr<!s32i>
-// CHECK: [[RET_VAL:%.*]] = cir.load [[RETVAL_ADDR]] : !cir.ptr<!s32i>,
+// CHECK: [[RET_VAL:%.*]] = cir.load{{.*}} [[RETVAL_ADDR]] : !cir.ptr<!s32i>,
 // CHECK: cir.return [[RET_VAL]] : !s32i
 
 // LLVM-LABEL: @_ZZN1A3fooEvENKUlvE_clEv
@@ -340,13 +340,13 @@ struct A {
 // CHECK: [[ARG2_ADDR:%.*]] = cir.alloca !cir.ptr<!rec_anon2E8>, !cir.ptr<!cir.ptr<!rec_anon2E8>>, ["this", init] {alignment = 8 : i64}
 // CHECK: [[RETVAL_ADDR:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK: cir.store{{.*}} [[ARG2]], [[ARG2_ADDR]] : !cir.ptr<!rec_anon2E8>, !cir.ptr<!cir.ptr<!rec_anon2E8>>
-// CHECK: [[CLS_ANNO8:%.*]] = cir.load [[ARG2_ADDR]] : !cir.ptr<!cir.ptr<!rec_anon2E8>>, !cir.ptr<!rec_anon2E8>
+// CHECK: [[CLS_ANNO8:%.*]] = cir.load{{.*}} [[ARG2_ADDR]] : !cir.ptr<!cir.ptr<!rec_anon2E8>>, !cir.ptr<!rec_anon2E8>
 // CHECK: [[STRUCT_A_PTR:%.*]] = cir.get_member [[CLS_ANNO8]][0] {name = "this"} : !cir.ptr<!rec_anon2E8> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CHECK: [[STRUCT_A:%.*]] = cir.load [[STRUCT_A_PTR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
+// CHECK: [[STRUCT_A:%.*]] = cir.load{{.*}} [[STRUCT_A_PTR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
 // CHECK: [[a:%.*]] = cir.get_member [[STRUCT_A]][0] {name = "a"} : !cir.ptr<!rec_A> -> !cir.ptr<!s32i> loc(#loc70)
-// CHECK: [[TMP0:%.*]] = cir.load [[a]] : !cir.ptr<!s32i>, !s32i
+// CHECK: [[TMP0:%.*]] = cir.load{{.*}} [[a]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} [[TMP0]], [[RETVAL_ADDR]] : !s32i, !cir.ptr<!s32i>
-// CHECK: [[RET_VAL:%.*]] = cir.load [[RETVAL_ADDR]] : !cir.ptr<!s32i>
+// CHECK: [[RET_VAL:%.*]] = cir.load{{.*}} [[RETVAL_ADDR]] : !cir.ptr<!s32i>
 // CHECK: cir.return [[RET_VAL]] : !s32i
 
 // LLVM-LABEL: _ZZN1A3barEvENKUlvE_clEv
diff --git a/clang/test/CIR/CodeGen/libcall.cpp b/clang/test/CIR/CodeGen/libcall.cpp
index c8f87b3cb0a7..f03c310f07fe 100644
--- a/clang/test/CIR/CodeGen/libcall.cpp
+++ b/clang/test/CIR/CodeGen/libcall.cpp
@@ -42,7 +42,7 @@ void t(const char* fmt, ...) {
 // CHECK: cir.func @_Z15consume_messagePKc(%arg0: !cir.ptr<!s8i>
 // CHECK:   %0 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["m", init] {alignment = 8 : i64}
 
-// CHECK:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+// CHECK:   %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
 // CHECK:   %4 = cir.objsize(%3 : <!s8i>, max) -> !u64i
 // CHECK:   %5 = cir.call @_ZL6strlenPKcU17pass_object_size0(%3, %4) : (!cir.ptr<!s8i>, !u64i) -> !u64i
 
@@ -57,7 +57,7 @@ void t(const char* fmt, ...) {
 
 // CHECK: cir.store %arg1, %1 : !u64i, !cir.ptr<!u64i>
 
-// CHECK: %10 = cir.load %1 : !cir.ptr<!u64i>, !u64i
-// CHECK: %11 = cir.load %3 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
-// CHECK: %12 = cir.load %4 : !cir.ptr<!cir.ptr<!rec___va_list_tag>>, !cir.ptr<!rec___va_list_tag>
+// CHECK: %10 = cir.load{{.*}} %1 : !cir.ptr<!u64i>, !u64i
+// CHECK: %11 = cir.load{{.*}} %3 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+// CHECK: %12 = cir.load{{.*}} %4 : !cir.ptr<!cir.ptr<!rec___va_list_tag>>, !cir.ptr<!rec___va_list_tag>
 // CHECK: %13 = cir.call @__vsnprintf_chk(%6, %8, %9, %10, %11, %12)
diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp
index 39dbad125eab..ef781c9e4dbf 100644
--- a/clang/test/CIR/CodeGen/loop.cpp
+++ b/clang/test/CIR/CodeGen/loop.cpp
@@ -20,20 +20,20 @@ void l1() {
 
 // CHECK: cir.func @_Z2l1v
 // CHECK: cir.for : cond {
-// CHECK-NEXT:   %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %4 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   %5 = cir.const #cir.int<10> : !s32i
 // CHECK-NEXT:   %6 = cir.cmp(lt, %4, %5) : !s32i, !cir.bool
 // CHECK-NEXT:   cir.condition(%6)
 // CHECK-NEXT: } body {
 // CHECK-NEXT:   cir.scope {
-// CHECK-NEXT:     %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:     %4 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:     %5 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:     %6 = cir.binop(add, %4, %5) nsw : !s32i
 // CHECK-NEXT:     cir.store{{.*}} %6, %0 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:   }
 // CHECK-NEXT:   cir.yield
 // CHECK-NEXT: } step {
-// CHECK-NEXT:   %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %4 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   %5 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:   %6 = cir.binop(add, %4, %5) nsw : !s32i
 // CHECK-NEXT:   cir.store{{.*}} %6, %2 : !s32i, !cir.ptr<!s32i>
@@ -56,11 +56,11 @@ void l2(bool cond) {
 // CHECK: cir.func @_Z2l2b
 // CHECK:         cir.scope {
 // CHECK-NEXT:     cir.while {
-// CHECK-NEXT:       %3 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT:       %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK-NEXT:       cir.condition(%3)
 // CHECK-NEXT:     } do {
 // CHECK-NEXT:       cir.scope {
-// CHECK-NEXT:         %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:         %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:         %4 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:         %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK-NEXT:         cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
@@ -74,7 +74,7 @@ void l2(bool cond) {
 // CHECK-NEXT:       cir.condition(%[[#TRUE]])
 // CHECK-NEXT:     } do {
 // CHECK-NEXT:       cir.scope {
-// CHECK-NEXT:         %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:         %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:         %4 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:         %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK-NEXT:         cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void l2(bool cond) {
 // CHECK-NEXT:       cir.condition(%4)
 // CHECK-NEXT:     } do {
 // CHECK-NEXT:       cir.scope {
-// CHECK-NEXT:         %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:         %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:         %4 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:         %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK-NEXT:         cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
@@ -115,21 +115,21 @@ void l3(bool cond) {
 // CHECK: cir.scope {
 // CHECK-NEXT:   cir.do {
 // CHECK-NEXT:     cir.scope {
-// CHECK-NEXT:       %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:       %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:       %4 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:       %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK-NEXT:       cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:     }
 // CHECK-NEXT:     cir.yield
 // CHECK-NEXT:   } while {
-// CHECK-NEXT:     %[[#TRUE:]] = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT:     %[[#TRUE:]] = cir.load{{.*}} %0 : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK-NEXT:     cir.condition(%[[#TRUE]])
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 // CHECK-NEXT: cir.scope {
 // CHECK-NEXT:   cir.do {
 // CHECK-NEXT:     cir.scope {
-// CHECK-NEXT:       %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:       %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:       %4 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:       %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK-NEXT:       cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
@@ -143,7 +143,7 @@ void l3(bool cond) {
 // CHECK-NEXT: cir.scope {
 // CHECK-NEXT:   cir.do {
 // CHECK-NEXT:     cir.scope {
-// CHECK-NEXT:       %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:       %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:       %4 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:       %5 = cir.binop(add, %3, %4) nsw : !s32i
 // CHECK-NEXT:       cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
@@ -172,12 +172,12 @@ void l4() {
 // CHECK-NEXT:   cir.condition(%[[#TRUE]])
 // CHECK-NEXT: } do {
 // CHECK-NEXT:   cir.scope {
-// CHECK-NEXT:     %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:     %4 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:     %5 = cir.const #cir.int<1> : !s32i
 // CHECK-NEXT:     %6 = cir.binop(add, %4, %5) nsw  : !s32i
 // CHECK-NEXT:     cir.store{{.*}} %6, %0 : !s32i, !cir.ptr<!s32i>
 // CHECK-NEXT:     cir.scope {
-// CHECK-NEXT:       %10 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:       %10 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:       %11 = cir.const #cir.int<10> : !s32i
 // CHECK-NEXT:       %12 = cir.cmp(lt, %10, %11) : !s32i, !cir.bool
 // CHECK-NEXT:       cir.if %12 {
diff --git a/clang/test/CIR/CodeGen/new-null.cpp b/clang/test/CIR/CodeGen/new-null.cpp
index 75443f9cb0b2..bd708ab266ce 100644
--- a/clang/test/CIR/CodeGen/new-null.cpp
+++ b/clang/test/CIR/CodeGen/new-null.cpp
@@ -50,7 +50,7 @@ namespace test15 {
   // CIR:           %[[VAL_1:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init] {alignment = 8 : i64}
   // CIR:           cir.store %[[VAL_0]], %[[VAL_1]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
   // CIR:           %[[VAL_2:.*]] = cir.const #cir.int<1> : !u64i
-  // CIR:           %[[VAL_3:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+  // CIR:           %[[VAL_3:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
   // CIR:           %[[VAL_4:.*]] = cir.const #true
   // CIR:           %[[VAL_5:.*]] = cir.call @_ZnwmPvb(%[[VAL_2]], %[[VAL_3]], %[[VAL_4]])
   // CIR:           %[[VAL_6:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp
index 967e337172bb..3ee57f7dd75a 100644
--- a/clang/test/CIR/CodeGen/new.cpp
+++ b/clang/test/CIR/CodeGen/new.cpp
@@ -21,10 +21,10 @@ void m(int a, int b) {
 // CHECK:     %4 = cir.const #cir.int<1> : !u64i
 // CHECK:     %5 = cir.call @_Znwm(%4) : (!u64i) -> !cir.ptr<!void>
 // CHECK:     %6 = cir.cast(bitcast, %5 : !cir.ptr<!void>), !cir.ptr<!rec_S>
-// CHECK:     %7 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK:     %8 = cir.load %7 : !cir.ptr<!s32i>, !s32i
-// CHECK:     %9 = cir.load %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// CHECK:     %10 = cir.load %9 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %7 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:     %8 = cir.load{{.*}} %7 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %9 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:     %10 = cir.load{{.*}} %9 : !cir.ptr<!s32i>, !s32i
 // CHECK:     cir.call @_ZN1SC1Eii(%6, %8, %10) : (!cir.ptr<!rec_S>, !s32i, !s32i) -> ()
 // CHECK:     cir.call @_ZNSt10shared_ptrI1SEC1EPS0_(%2, %6) : (!cir.ptr<!rec_std3A3Ashared_ptr3CS3E>, !cir.ptr<!rec_S>) -> ()
 // CHECK:   }
@@ -41,9 +41,9 @@ class B {
 // CHECK:   %1 = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["__p", init] {alignment = 8 : i64}
 // CHECK:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
 // CHECK:   cir.store{{.*}} %arg1, %1 : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
-// CHECK:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
+// CHECK:   %2 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
 // CHECK:   %3 = cir.const #cir.int<1> : !u64i
-// CHECK:   %4 = cir.load %1 : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
+// CHECK:   %4 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
 // CHECK:   %5 = cir.cast(bitcast, %4 : !cir.ptr<!rec_B>), !cir.ptr<!void>
 // CHECK:   %6 = cir.cast(bitcast, %5 : !cir.ptr<!void>), !cir.ptr<!rec_B>
 
@@ -195,7 +195,7 @@ void t_new_var_size(size_t n) {
 }
 
 // CHECK:  cir.func @_Z14t_new_var_sizem
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[PTR:.*]] = cir.call @_Znam(%[[N]]) : (!u64i)
 
 void t_new_var_size2(int n) {
@@ -203,7 +203,7 @@ void t_new_var_size2(int n) {
 }
 
 // CHECK:  cir.func @_Z15t_new_var_size2i
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
 // CHECK:    %[[PTR:.*]] = cir.call @_Znam(%[[N_SIZE_T]]) : (!u64i)
 
@@ -212,7 +212,7 @@ void t_new_var_size3(size_t n) {
 }
 
 // CHECK:  cir.func @_Z15t_new_var_size3m
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[ELEMENT_SIZE:.*]] = cir.const #cir.int<8> : !u64i
 // CHECK:    %[[RESULT:.*]], %[[OVERFLOW:.*]] = cir.binop.overflow(mul, %[[N]], %[[ELEMENT_SIZE]]) : !u64i, (!u64i, !cir.bool)
 // CHECK:    %[[ALL_ONES:.*]] = cir.const #cir.int<18446744073709551615> : !u64i
@@ -224,7 +224,7 @@ void t_new_var_size4(int n) {
 }
 
 // CHECK:  cir.func @_Z15t_new_var_size4i
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
 // CHECK:    %[[ELEMENT_SIZE:.*]] = cir.const #cir.int<8> : !u64i
 // CHECK:    %[[RESULT:.*]], %[[OVERFLOW:.*]] = cir.binop.overflow(mul, %[[N_SIZE_T]], %[[ELEMENT_SIZE]]) : !u64i, (!u64i, !cir.bool)
@@ -239,7 +239,7 @@ void t_new_var_size5(int n) {
 // NUM_ELEMENTS isn't used in this case because there is no cookie.
 
 // CHECK:  cir.func @_Z15t_new_var_size5i
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
 // CHECK:    %[[ELEMENT_SIZE:.*]] = cir.const #cir.int<48> : !u64i
 // CHECK:    %[[RESULT:.*]], %[[OVERFLOW:.*]] = cir.binop.overflow(mul, %[[N_SIZE_T]], %[[ELEMENT_SIZE]]) : !u64i, (!u64i, !cir.bool)
@@ -254,7 +254,7 @@ void t_new_var_size6(int n) {
 }
 
 // CHECK:  cir.func @_Z15t_new_var_size6i
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
 // CHECK:    %[[MIN_SIZE:.*]] = cir.const #cir.int<3> : !u64i
 // CHECK:    %[[LT_MIN_SIZE:.*]] = cir.cmp(lt, %[[N_SIZE_T]], %[[MIN_SIZE]]) : !u64i, !cir.bool
@@ -270,7 +270,7 @@ void t_new_var_size7(__int128 n) {
 }
 
 // CHECK:  cir.func @_Z15t_new_var_size7n
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s128i), !u64i
 // CHECK:    %[[ELEMENT_SIZE:.*]] = cir.const #cir.int<8> : !u64i
 // CHECK:    %[[RESULT:.*]], %[[OVERFLOW:.*]] = cir.binop.overflow(mul, %[[N_SIZE_T]], %[[ELEMENT_SIZE]]) : !u64i, (!u64i, !cir.bool)
@@ -283,7 +283,7 @@ void t_new_var_size_nontrivial(size_t n) {
 }
 
 // CHECK:  cir.func @_Z25t_new_var_size_nontrivialm
-// CHECK:    %[[N:.*]] = cir.load %[[ARG_ALLOCA:.*]]
+// CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
 // CHECK:    %[[ELEMENT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
 // CHECK:    %[[SIZE_WITHOUT_COOKIE:.*]], %[[OVERFLOW:.*]] = cir.binop.overflow(mul, %[[N]], %[[ELEMENT_SIZE]]) : !u64i, (!u64i, !cir.bool)
 // CHECK:    %[[COOKIE_SIZE:.*]] = cir.const #cir.int<8> : !u64i
diff --git a/clang/test/CIR/CodeGen/no-proto-fun-ptr.c b/clang/test/CIR/CodeGen/no-proto-fun-ptr.c
index e44ce441c5b4..88127468399d 100644
--- a/clang/test/CIR/CodeGen/no-proto-fun-ptr.c
+++ b/clang/test/CIR/CodeGen/no-proto-fun-ptr.c
@@ -21,7 +21,7 @@ void buz() {
 
 // CHECK:  cir.func no_proto @buz()
 // CHECK:    [[FNPTR_ALLOC:%.*]] = cir.alloca !cir.ptr<!cir.func<(...)>>, !cir.ptr<!cir.ptr<!cir.func<(...)>>>, ["func"] {alignment = 8 : i64}
-// CHECK:    [[FNPTR:%.*]] = cir.load deref [[FNPTR_ALLOC]] : !cir.ptr<!cir.ptr<!cir.func<(...)>>>, !cir.ptr<!cir.func<(...)>>
+// CHECK:    [[FNPTR:%.*]] = cir.load deref{{.*}} [[FNPTR_ALLOC]] : !cir.ptr<!cir.ptr<!cir.func<(...)>>>, !cir.ptr<!cir.func<(...)>>
 // CHECK:    [[CAST:%.*]] = cir.cast(bitcast, %1 : !cir.ptr<!cir.func<(...)>>), !cir.ptr<!cir.func<()>>
 // CHECK:    cir.call [[CAST]]() : (!cir.ptr<!cir.func<()>>) -> ()
 // CHECK:    cir.return
diff --git a/clang/test/CIR/CodeGen/nullptr-init.cpp b/clang/test/CIR/CodeGen/nullptr-init.cpp
index 451838483370..05602aef1a43 100644
--- a/clang/test/CIR/CodeGen/nullptr-init.cpp
+++ b/clang/test/CIR/CodeGen/nullptr-init.cpp
@@ -56,9 +56,9 @@ int t2() {
 // CIR-NEXT:      %[[NULLPTR_EXTRA:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!void>
 // CIR-NEXT:      %[[NULLPTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
 // CIR-NEXT:      cir.store{{.*}} %[[NULLPTR]], %[[P]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
-// CIR-NEXT:      %[[X_VAL:.*]] = cir.load %[[X]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:      %[[X_VAL:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:      cir.store{{.*}} %[[X_VAL]], %[[RETVAL_ADDR]] : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT:      %[[RETVAL:.*]] = cir.load %[[RETVAL_ADDR]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT:      %[[RETVAL:.*]] = cir.load{{.*}} %[[RETVAL_ADDR]] : !cir.ptr<!s32i>, !s32i
 // CIR-NEXT:      cir.return %[[RETVAL]] : !s32i
 // CIR-NEXT:  }
 
diff --git a/clang/test/CIR/CodeGen/pointer-arith-ext.c b/clang/test/CIR/CodeGen/pointer-arith-ext.c
index c1a3d374b44b..0b4c4d237b5c 100644
--- a/clang/test/CIR/CodeGen/pointer-arith-ext.c
+++ b/clang/test/CIR/CodeGen/pointer-arith-ext.c
@@ -7,8 +7,8 @@
 typedef void (*FP)(void);
 void *f2(void *a, int b) { return a + b; }
 // CIR-LABEL: f2
-// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
-// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR: %[[STRIDE:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!void>, %[[STRIDE]] : !s32i)
 
 // LLVM-LABEL: f2
@@ -33,8 +33,8 @@ void *f3_1(int a, void *b) { return (a += b); }
 
 void *f4(void *a, int b) { return a - b; }
 // CIR-LABEL: f4
-// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
-// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR: %[[STRIDE:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: %[[SUB:.*]] = cir.unary(minus, %[[STRIDE]]) : !s32i, !s32i
 // CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!void>, %[[SUB]] : !s32i)
 
@@ -50,8 +50,8 @@ void *f4_1(void *a, int b) { return (a -= b); }
 
 FP f5(FP a, int b) { return a + b; }
 // CIR-LABEL: f5
-// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!cir.func<()>>>, !cir.ptr<!cir.func<()>>
-// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!cir.func<()>>>, !cir.ptr<!cir.func<()>>
+// CIR: %[[STRIDE:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!cir.func<()>>, %[[STRIDE]] : !s32i)
 
 // LLVM-LABEL: f5
@@ -67,8 +67,8 @@ FP f6_1(int a, FP b) { return (a += b); }
 
 FP f7(FP a, int b) { return a - b; }
 // CIR-LABEL: f7
-// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!cir.func<()>>>, !cir.ptr<!cir.func<()>>
-// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!cir.func<()>>>, !cir.ptr<!cir.func<()>>
+// CIR: %[[STRIDE:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: %[[SUB:.*]] = cir.unary(minus, %[[STRIDE]]) : !s32i, !s32i
 // CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!cir.func<()>>, %[[SUB]] : !s32i)
 
@@ -84,8 +84,8 @@ FP f7_1(FP a, int b) { return (a -= b); }
 
 void f8(void *a, int b) { return *(a + b); }
 // CIR-LABEL: f8
-// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
-// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR: %[[STRIDE:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!void>, %[[STRIDE]] : !s32i)
 // CIR: cir.return
 
@@ -98,8 +98,8 @@ void f8(void *a, int b) { return *(a + b); }
 
 void f8_1(void *a, int b) { return a[b]; }
 // CIR-LABEL: f8_1
-// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
-// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: %[[PTR:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR: %[[STRIDE:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!void>, %[[STRIDE]] : !s32i)
 // CIR: cir.return
 
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
index 19cb05cd2a73..e8e82b73310f 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
@@ -84,7 +84,7 @@ bool to_bool(int Foo::*x) {
 }
 
 // CIR-LABEL: @_Z7to_boolM3Fooi
-//      CIR:   %[[#x:]] = cir.load %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
+//      CIR:   %[[#x:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
 // CIR-NEXT:   %{{.+}} = cir.cast(member_ptr_to_bool, %[[#x]] : !cir.data_member<!s32i in !rec_Foo>), !cir.bool
 //      CIR: }
 
@@ -93,6 +93,6 @@ auto bitcast(int Foo::*x) {
 }
 
 // CIR-LABEL: @_Z7bitcastM3Fooi
-//      CIR:   %[[#x:]] = cir.load %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
+//      CIR:   %[[#x:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
 // CIR-NEXT:   %{{.+}} = cir.cast(bitcast, %[[#x]] : !cir.data_member<!s32i in !rec_Foo>), !cir.data_member<!s32i in !rec_Bar>
 //      CIR: }
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member-cmp.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member-cmp.cpp
index 3dc408ab7a69..f3413a01a477 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member-cmp.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member-cmp.cpp
@@ -16,8 +16,8 @@ bool eq(int Foo::*x, int Foo::*y) {
 }
 
 // CIR-LABEL: @_Z2eqM3FooiS0_
-//      CIR:   %[[#x:]] = cir.load %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
-// CIR-NEXT:   %[[#y:]] = cir.load %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
+//      CIR:   %[[#x:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
+// CIR-NEXT:   %[[#y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
 // CIR-NEXT:   %{{.+}} = cir.cmp(eq, %[[#x]], %[[#y]]) : !cir.data_member<!s32i in !rec_Foo>, !cir.bool
 //      CIR: }
 
@@ -32,8 +32,8 @@ bool ne(int Foo::*x, int Foo::*y) {
 }
 
 // CIR-LABEL: @_Z2neM3FooiS0_
-//      CIR:   %[[#x:]] = cir.load %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
-// CIR-NEXT:   %[[#y:]] = cir.load %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
+//      CIR:   %[[#x:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
+// CIR-NEXT:   %[[#y:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.data_member<!s32i in !rec_Foo>>, !cir.data_member<!s32i in !rec_Foo>
 // CIR-NEXT:   %{{.+}} = cir.cmp(ne, %[[#x]], %[[#y]]) : !cir.data_member<!s32i in !rec_Foo>, !cir.bool
 //      CIR: }
 
diff --git a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
index 246912fd2bc0..80105aa5c227 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
@@ -51,7 +51,7 @@ void call(Foo *obj, void (Foo::*func)(int), int arg) {
 
 // CHECK-LABEL: cir.func @_Z4callP3FooMS_FviEi
 //       CHECK:   %[[CALLEE:.+]], %[[THIS:.+]] = cir.get_method %{{.+}}, %{{.+}} : (!cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!rec_Foo>) -> (!cir.ptr<!cir.func<(!cir.ptr<!void>, !s32i)>>, !cir.ptr<!void>)
-//  CHECK-NEXT:   %[[#ARG:]] = cir.load %{{.+}} : !cir.ptr<!s32i>, !s32i
+//  CHECK-NEXT:   %[[#ARG:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!s32i>, !s32i
 //  CHECK-NEXT:   cir.call %[[CALLEE]](%[[THIS]], %[[#ARG]]) : (!cir.ptr<!cir.func<(!cir.ptr<!void>, !s32i)>>, !cir.ptr<!void>, !s32i) -> ()
 //       CHECK: }
 
diff --git a/clang/test/CIR/CodeGen/pointers.cpp b/clang/test/CIR/CodeGen/pointers.cpp
index dfea22ebadd6..98afc6ef1b2f 100644
--- a/clang/test/CIR/CodeGen/pointers.cpp
+++ b/clang/test/CIR/CodeGen/pointers.cpp
@@ -18,12 +18,12 @@ void foo(int *iptr, char *cptr, unsigned ustride) {
   // CHECK: %[[#NEGSTRIDE:]] = cir.unary(minus, %[[#STRIDE]]) : !s32i, !s32i
   // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr<!s8i>, %[[#NEGSTRIDE]] : !s32i), !cir.ptr<!s8i>
   iptr + ustride;
-  // CHECK: %[[#STRIDE:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
+  // CHECK: %[[#STRIDE:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
   // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr<!s32i>, %[[#STRIDE]] : !u32i), !cir.ptr<!s32i>
 
   // Must convert unsigned stride to a signed one.
   iptr - ustride;
-  // CHECK: %[[#STRIDE:]] = cir.load %{{.+}} : !cir.ptr<!u32i>, !u32i
+  // CHECK: %[[#STRIDE:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
   // CHECK: %[[#SIGNSTRIDE:]] = cir.cast(integral, %[[#STRIDE]] : !u32i), !s32i
   // CHECK: %[[#NEGSTRIDE:]] = cir.unary(minus, %[[#SIGNSTRIDE]]) : !s32i, !s32i
   // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr<!s32i>, %[[#NEGSTRIDE]] : !s32i), !cir.ptr<!s32i>
@@ -32,7 +32,7 @@ void foo(int *iptr, char *cptr, unsigned ustride) {
 void testPointerSubscriptAccess(int *ptr) {
 // CHECK: testPointerSubscriptAccess
   ptr[1];
-  // CHECK: %[[#V1:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+  // CHECK: %[[#V1:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
   // CHECK: %[[#V2:]] = cir.const #cir.int<1> : !s32i
   // CHECK: cir.ptr_stride(%[[#V1]] : !cir.ptr<!s32i>, %[[#V2]] : !s32i), !cir.ptr<!s32i>
 }
@@ -40,10 +40,10 @@ void testPointerSubscriptAccess(int *ptr) {
 void testPointerMultiDimSubscriptAccess(int **ptr) {
 // CHECK: testPointerMultiDimSubscriptAccess
   ptr[1][2];
-  // CHECK: %[[#V1:]] = cir.load %{{.+}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!s32i>>
+  // CHECK: %[[#V1:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!s32i>>
   // CHECK: %[[#V2:]] = cir.const #cir.int<1> : !s32i
   // CHECK: %[[#V3:]] = cir.ptr_stride(%[[#V1]] : !cir.ptr<!cir.ptr<!s32i>>, %[[#V2]] : !s32i), !cir.ptr<!cir.ptr<!s32i>>
-  // CHECK: %[[#V4:]] = cir.load %[[#V3]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+  // CHECK: %[[#V4:]] = cir.load{{.*}} %[[#V3]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
   // CHECK: %[[#V5:]] = cir.const #cir.int<2> : !s32i
   // CHECK: cir.ptr_stride(%[[#V4]] : !cir.ptr<!s32i>, %[[#V5]] : !s32i), !cir.ptr<!s32i>
 }
diff --git a/clang/test/CIR/CodeGen/ptrdiff.cpp b/clang/test/CIR/CodeGen/ptrdiff.cpp
index e322c9c6388a..6c30fb01660d 100644
--- a/clang/test/CIR/CodeGen/ptrdiff.cpp
+++ b/clang/test/CIR/CodeGen/ptrdiff.cpp
@@ -7,8 +7,8 @@ size_type size(unsigned long *_start, unsigned long *_finish) {
 }
 
 // CHECK: cir.func @_Z4sizePmS_(%arg0: !cir.ptr<!u64i>
-// CHECK:   %3 = cir.load %1 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
-// CHECK:   %4 = cir.load %0 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+// CHECK:   %3 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+// CHECK:   %4 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
 // CHECK:   %5 = cir.ptr_diff(%3, %4) : !cir.ptr<!u64i> -> !s64i
 // CHECK:   %6 = cir.cast(integral, %5 : !s64i), !u64i
 
diff --git a/clang/test/CIR/CodeGen/rangefor.cpp b/clang/test/CIR/CodeGen/rangefor.cpp
index 4955e793e47b..5bd92c00f413 100644
--- a/clang/test/CIR/CodeGen/rangefor.cpp
+++ b/clang/test/CIR/CodeGen/rangefor.cpp
@@ -29,7 +29,7 @@ void init(unsigned numImages) {
 // CHECK:   %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["numImages", init] {alignment = 4 : i64}
 // CHECK:   %1 = cir.alloca ![[VEC]], !cir.ptr<![[VEC]]>, ["images", init] {alignment = 8 : i64}
 // CHECK:   cir.store{{.*}} %arg0, %0 : !u32i, !cir.ptr<!u32i>
-// CHECK:   %2 = cir.load %0 : !cir.ptr<!u32i>, !u32i
+// CHECK:   %2 = cir.load{{.*}} %0 : !cir.ptr<!u32i>, !u32i
 // CHECK:   %3 = cir.cast(integral, %2 : !u32i), !u64i
 // CHECK:   cir.call @_ZNSt6vectorI6tripleEC1Em(%1, %3) : (!cir.ptr<![[VEC]]>, !u64i) -> ()
 // CHECK:   cir.scope {
@@ -38,10 +38,10 @@ void init(unsigned numImages) {
 // CHECK:     %6 = cir.alloca ![[VEC_IT]], !cir.ptr<![[VEC_IT]]>, ["__end1", init] {alignment = 8 : i64}
 // CHECK:     %7 = cir.alloca !cir.ptr<!rec_triple>, !cir.ptr<!cir.ptr<!rec_triple>>, ["image", init, const] {alignment = 8 : i64}
 // CHECK:     cir.store{{.*}} %1, %4 : !cir.ptr<![[VEC]]>, !cir.ptr<!cir.ptr<![[VEC]]>>
-// CHECK:     %8 = cir.load %4 : !cir.ptr<!cir.ptr<![[VEC]]>>, !cir.ptr<![[VEC]]>
+// CHECK:     %8 = cir.load{{.*}} %4 : !cir.ptr<!cir.ptr<![[VEC]]>>, !cir.ptr<![[VEC]]>
 // CHECK:     %9 = cir.call @_ZNSt6vectorI6tripleE5beginEv(%8) : (!cir.ptr<![[VEC]]>) -> ![[VEC_IT]]
 // CHECK:     cir.store{{.*}} %9, %5 : ![[VEC_IT]], !cir.ptr<![[VEC_IT]]>
-// CHECK:     %10 = cir.load %4 : !cir.ptr<!cir.ptr<![[VEC]]>>, !cir.ptr<![[VEC]]>
+// CHECK:     %10 = cir.load{{.*}} %4 : !cir.ptr<!cir.ptr<![[VEC]]>>, !cir.ptr<![[VEC]]>
 // CHECK:     %11 = cir.call @_ZNSt6vectorI6tripleE3endEv(%10) : (!cir.ptr<![[VEC]]>) -> ![[VEC_IT]]
 // CHECK:     cir.store{{.*}} %11, %6 : ![[VEC_IT]], !cir.ptr<![[VEC_IT]]>
 // CHECK:     cir.for : cond {
@@ -59,7 +59,7 @@ void init(unsigned numImages) {
 // CHECK:         cir.store{{.*}} %16, %15 : !u32i, !cir.ptr<!u32i>
 // CHECK:         %17 = cir.get_member %13[1] {name = "next"} : !cir.ptr<!rec_triple> -> !cir.ptr<!cir.ptr<!void>>
 // CHECK:         %18 = cir.get_member %13[2] {name = "image"} : !cir.ptr<!rec_triple> -> !cir.ptr<!u32i>
-// CHECK:         %19 = cir.load %7 : !cir.ptr<!cir.ptr<!rec_triple>>, !cir.ptr<!rec_triple>
+// CHECK:         %19 = cir.load{{.*}} %7 : !cir.ptr<!cir.ptr<!rec_triple>>, !cir.ptr<!rec_triple>
 // CHECK:         %20 = cir.call @_ZN6tripleaSEOS_(%19, %13) : (!cir.ptr<!rec_triple>, !cir.ptr<!rec_triple>) -> !cir.ptr<!rec_triple>
 // CHECK:       }
 // CHECK:       cir.yield
diff --git a/clang/test/CIR/CodeGen/sourcelocation.cpp b/clang/test/CIR/CodeGen/sourcelocation.cpp
index 86ae88c5137d..879d59255dea 100644
--- a/clang/test/CIR/CodeGen/sourcelocation.cpp
+++ b/clang/test/CIR/CodeGen/sourcelocation.cpp
@@ -26,12 +26,12 @@ int s0(int a, int b) {
 // CIR:     %3 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64} loc(#loc23)
 // CIR:     cir.store{{.*}} %arg0, %0 : !s32i, !cir.ptr<!s32i> loc(#loc9)
 // CIR:     cir.store{{.*}} %arg1, %1 : !s32i, !cir.ptr<!s32i> loc(#loc9)
-// CIR:     %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i loc(#loc10)
-// CIR:     %5 = cir.load %1 : !cir.ptr<!s32i>, !s32i loc(#loc8)
+// CIR:     %4 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i loc(#loc10)
+// CIR:     %5 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i loc(#loc8)
 // CIR:     %6 = cir.binop(add, %4, %5) nsw : !s32i loc(#loc10)
 // CIR:     cir.store{{.*}} %6, %3 : !s32i, !cir.ptr<!s32i> loc(#loc23)
 // CIR:     cir.scope {
-// CIR:       %9 = cir.load %3 : !cir.ptr<!s32i>, !s32i loc(#loc13)
+// CIR:       %9 = cir.load{{.*}} %3 : !cir.ptr<!s32i>, !s32i loc(#loc13)
 // CIR:       %10 = cir.const #cir.int<0> : !s32i loc(#loc14)
 // CIR:       %11 = cir.cmp(gt, %9, %10) : !s32i, !cir.bool loc(#loc25)
 // CIR:       cir.if %11 {
@@ -42,9 +42,9 @@ int s0(int a, int b) {
 // CIR:         cir.store{{.*}} %12, %3 : !s32i, !cir.ptr<!s32i> loc(#loc28)
 // CIR:       } loc(#loc26)
 // CIR:     } loc(#loc24)
-// CIR:     %7 = cir.load %3 : !cir.ptr<!s32i>, !s32i loc(#loc18)
+// CIR:     %7 = cir.load{{.*}} %3 : !cir.ptr<!s32i>, !s32i loc(#loc18)
 // CIR:     cir.store{{.*}} %7, %2 : !s32i, !cir.ptr<!s32i> loc(#loc29)
-// CIR:     %8 = cir.load %2 : !cir.ptr<!s32i>, !s32i loc(#loc29)
+// CIR:     %8 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i loc(#loc29)
 // CIR:     cir.return %8 : !s32i loc(#loc29)
 // CIR:   } loc(#loc20)
 // CIR: } loc(#loc)
diff --git a/clang/test/CIR/CodeGen/static-vars.c b/clang/test/CIR/CodeGen/static-vars.c
index 978ad2ccdd0f..71a65839375d 100644
--- a/clang/test/CIR/CodeGen/static-vars.c
+++ b/clang/test/CIR/CodeGen/static-vars.c
@@ -23,7 +23,7 @@ void func1(void) {
   // Should lower basic static vars arithmetics.
   j++;
   // CHECK-DAG: %[[#V2:]] = cir.get_global @func1.j : !cir.ptr<!s32i>
-  // CHECK-DAG: %[[#V3:]] = cir.load %[[#V2]] : !cir.ptr<!s32i>, !s32i
+  // CHECK-DAG: %[[#V3:]] = cir.load{{.*}} %[[#V2]] : !cir.ptr<!s32i>, !s32i
   // CHECK-DAG: %[[#V4:]] = cir.unary(inc, %[[#V3]]) nsw : !s32i, !s32i
   // CHECK-DAG: cir.store{{.*}} %[[#V4]], %[[#V2]] : !s32i, !cir.ptr<!s32i>
 }
diff --git a/clang/test/CIR/CodeGen/static-vars.cpp b/clang/test/CIR/CodeGen/static-vars.cpp
index e50e667a9a6f..2edaef716596 100644
--- a/clang/test/CIR/CodeGen/static-vars.cpp
+++ b/clang/test/CIR/CodeGen/static-vars.cpp
@@ -25,7 +25,7 @@ void func1(void) {
   // Should lower basic static vars arithmetics.
   j++;
   // CHECK-DAG: %[[#V2:]] = cir.get_global @_ZZ5func1vE1j : !cir.ptr<!s32i>
-  // CHECK-DAG: %[[#V3:]] = cir.load %[[#V2]] : !cir.ptr<!s32i>, !s32i
+  // CHECK-DAG: %[[#V3:]] = cir.load{{.*}} %[[#V2]] : !cir.ptr<!s32i>, !s32i
   // CHECK-DAG: %[[#V4:]] = cir.unary(inc, %[[#V3]]) nsw : !s32i, !s32i
   // CHECK-DAG: cir.store{{.*}} %[[#V4]], %[[#V2]] : !s32i, !cir.ptr<!s32i>
 }
diff --git a/clang/test/CIR/CodeGen/stmt-expr.c b/clang/test/CIR/CodeGen/stmt-expr.c
index 761e472600fb..a5dba8c8bbf0 100644
--- a/clang/test/CIR/CodeGen/stmt-expr.c
+++ b/clang/test/CIR/CodeGen/stmt-expr.c
@@ -14,10 +14,10 @@ void test2() { ({int x = 3; x; }); }
 // CHECK: cir.scope {
 // CHECK:   %[[#VAR:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
 //          [...]
-// CHECK:   %[[#TMP:]] = cir.load %[[#VAR]] : !cir.ptr<!s32i>, !s32i
+// CHECK:   %[[#TMP:]] = cir.load{{.*}} %[[#VAR]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   cir.store{{.*}} %[[#TMP]], %[[#RETVAL]] : !s32i, !cir.ptr<!s32i>
 // CHECK: }
-// CHECK: %{{.+}} = cir.load %[[#RETVAL]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %{{.+}} = cir.load{{.*}} %[[#RETVAL]] : !cir.ptr<!s32i>, !s32i
 
 // Yields an aggregate.
 struct S { int x; };
@@ -30,7 +30,7 @@ int test3() { return ({ struct S s = {1}; s; }).x; }
 // CHECK:   cir.copy %[[#VAR]] to %[[#RETVAL]] : !cir.ptr<!rec_S>
 // CHECK: }
 // CHECK: %[[#RETADDR:]] = cir.get_member %1[0] {name = "x"} : !cir.ptr<!rec_S> -> !cir.ptr<!s32i>
-// CHECK: %{{.+}} = cir.load %[[#RETADDR]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %{{.+}} = cir.load{{.*}} %[[#RETADDR]] : !cir.ptr<!s32i>, !s32i
 
 // Expression is wrapped in an expression attribute (just ensure it does not crash).
 void test4(int x) { ({[[gsl::suppress("foo")]] x;}); }
diff --git a/clang/test/CIR/CodeGen/struct-comma.c b/clang/test/CIR/CodeGen/struct-comma.c
index ffd0544fda43..cab2e9aa31ff 100644
--- a/clang/test/CIR/CodeGen/struct-comma.c
+++ b/clang/test/CIR/CodeGen/struct-comma.c
@@ -8,7 +8,7 @@ void a(struct AA* b) {*b = (r(), x);}
 // CHECK-LABEL: @a
 // CHECK: %[[ADDR:.*]] = cir.alloca {{.*}} ["b"
 // CHECK: cir.store {{.*}}, %[[ADDR]]
-// CHECK: %[[LOAD:.*]] = cir.load deref %[[ADDR]]
+// CHECK: %[[LOAD:.*]] = cir.load deref{{.*}} %[[ADDR]]
 // CHECK: cir.call @r
 // CHECK: %[[GADDR:.*]] = cir.get_global @x
-// CHECK: cir.copy %[[GADDR]] to %[[LOAD]]
\ No newline at end of file
+// CHECK: cir.copy %[[GADDR]] to %[[LOAD]]
diff --git a/clang/test/CIR/CodeGen/struct-empty.c b/clang/test/CIR/CodeGen/struct-empty.c
index c657b983d31e..e36efdee1963 100644
--- a/clang/test/CIR/CodeGen/struct-empty.c
+++ b/clang/test/CIR/CodeGen/struct-empty.c
@@ -14,7 +14,7 @@ void __copy_fs_struct(struct fs_struct *fs) { fs->lock = (rwlock_t) { }; }
 // CIR:   %[[VAL_1:.*]] = cir.alloca !cir.ptr<![[fs_struct]]>, !cir.ptr<!cir.ptr<![[fs_struct]]>>, ["fs", init] {alignment = 8 : i64}
 // CIR:   %[[VAL_2:.*]] = cir.alloca ![[lock]], !cir.ptr<![[lock]]>, [".compoundliteral"] {alignment = 1 : i64}
 // CIR:   cir.store {{.*}}, %[[VAL_1]] : !cir.ptr<![[fs_struct]]>, !cir.ptr<!cir.ptr<![[fs_struct]]>>
-// CIR:   %[[VAL_3:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.ptr<![[fs_struct]]>>, !cir.ptr<![[fs_struct]]>
+// CIR:   %[[VAL_3:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.ptr<![[fs_struct]]>>, !cir.ptr<![[fs_struct]]>
 // CIR:   %[[VAL_4:.*]] = cir.get_member %[[VAL_3]][0] {name = "lock"} : !cir.ptr<![[fs_struct]]> -> !cir.ptr<![[lock]]>
 // CIR:   cir.copy %[[VAL_2]] to %[[VAL_4]] : !cir.ptr<![[lock]]>
 
diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c
index 8b6386b8c664..16013b640fea 100644
--- a/clang/test/CIR/CodeGen/struct.c
+++ b/clang/test/CIR/CodeGen/struct.c
@@ -78,7 +78,7 @@ struct S3 {
 void shouldCopyStructAsCallArg(struct S1 s) {
 // CHECK-DAG: cir.func @shouldCopyStructAsCallArg
   shouldCopyStructAsCallArg(s);
-  // CHECK-DAG: %[[#LV:]] = cir.load %{{.+}} : !cir.ptr<!rec_S1>, !rec_S1
+  // CHECK-DAG: %[[#LV:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!rec_S1>, !rec_S1
   // CHECK-DAG: cir.call @shouldCopyStructAsCallArg(%[[#LV]]) : (!rec_S1) -> ()
 }
 
diff --git a/clang/test/CIR/CodeGen/struct.cpp b/clang/test/CIR/CodeGen/struct.cpp
index 2d1acb5f054d..f150eb1c1e82 100644
--- a/clang/test/CIR/CodeGen/struct.cpp
+++ b/clang/test/CIR/CodeGen/struct.cpp
@@ -37,7 +37,7 @@ void yoyo(incomplete *i) {}
 //      CHECK: cir.func linkonce_odr @_ZN3Bar6methodEv(%arg0: !cir.ptr<!rec_Bar>
 // CHECK-NEXT:   %0 = cir.alloca !cir.ptr<!rec_Bar>, !cir.ptr<!cir.ptr<!rec_Bar>>, ["this", init] {alignment = 8 : i64}
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_Bar>, !cir.ptr<!cir.ptr<!rec_Bar>>
-// CHECK-NEXT:   %1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_Bar>>, !cir.ptr<!rec_Bar>
+// CHECK-NEXT:   %1 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_Bar>>, !cir.ptr<!rec_Bar>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
 
@@ -46,7 +46,7 @@ void yoyo(incomplete *i) {}
 // CHECK-NEXT:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_Bar>, !cir.ptr<!cir.ptr<!rec_Bar>>
 // CHECK-NEXT:   cir.store{{.*}} %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:   %2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_Bar>>, !cir.ptr<!rec_Bar>
+// CHECK-NEXT:   %2 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_Bar>>, !cir.ptr<!rec_Bar>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
 
@@ -56,10 +56,10 @@ void yoyo(incomplete *i) {}
 // CHECK-NEXT:   %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK-NEXT:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_Bar>, !cir.ptr<!cir.ptr<!rec_Bar>>
 // CHECK-NEXT:   cir.store{{.*}} %arg1, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_Bar>>, !cir.ptr<!rec_Bar>
-// CHECK-NEXT:   %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_Bar>>, !cir.ptr<!rec_Bar>
+// CHECK-NEXT:   %4 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   cir.store{{.*}} %4, %2 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:   %5 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %5 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   cir.return %5
 // CHECK-NEXT: }
 
@@ -97,7 +97,7 @@ void m() { Adv C; }
 // CHECK: cir.func linkonce_odr @_ZN3AdvC2Ev(%arg0: !cir.ptr<!rec_Adv>
 // CHECK:     %0 = cir.alloca !cir.ptr<!rec_Adv>, !cir.ptr<!cir.ptr<!rec_Adv>>, ["this", init] {alignment = 8 : i64}
 // CHECK:     cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_Adv>, !cir.ptr<!cir.ptr<!rec_Adv>>
-// CHECK:     %1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_Adv>>, !cir.ptr<!rec_Adv>
+// CHECK:     %1 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_Adv>>, !cir.ptr<!rec_Adv>
 // CHECK:     %2 = cir.get_member %1[0] {name = "x"} : !cir.ptr<!rec_Adv> -> !cir.ptr<!rec_Mandalore>
 // CHECK:     %3 = cir.get_member %2[0] {name = "w"} : !cir.ptr<!rec_Mandalore> -> !cir.ptr<!u32i>
 // CHECK:     %4 = cir.const #cir.int<1000024001> : !u32i
@@ -153,7 +153,7 @@ void h() { S s; }
 // CHECK:   %1 = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["agg.tmp0"] {alignment = 4 : i64}
 // CHECK:   %2 = cir.call @_Z11get_defaultv() : () -> !rec_A
 // CHECK:   cir.store{{.*}} %2, %1 : !rec_A, !cir.ptr<!rec_A>
-// CHECK:   %3 = cir.load %1 : !cir.ptr<!rec_A>, !rec_A
+// CHECK:   %3 = cir.load{{.*}} %1 : !cir.ptr<!rec_A>, !rec_A
 // CHECK:   cir.call @_ZN1SC1E1A(%0, %3) : (!cir.ptr<!rec_S>, !rec_A) -> ()
 // CHECK:   cir.return
 // CHECK: }
diff --git a/clang/test/CIR/CodeGen/switch.cpp b/clang/test/CIR/CodeGen/switch.cpp
index a46a9dbc9a6f..97d0f69d7a35 100644
--- a/clang/test/CIR/CodeGen/switch.cpp
+++ b/clang/test/CIR/CodeGen/switch.cpp
@@ -54,7 +54,7 @@ void sw3(int a) {
 
 // CHECK: cir.func @_Z3sw3i
 // CHECK: cir.scope {
-// CHECK-NEXT:   %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:   %1 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:   cir.switch (%1 : !s32i) {
 // CHECK-NEXT:   cir.case(default, []) {
 // CHECK-NEXT:     cir.break
@@ -79,7 +79,7 @@ int sw4(int a) {
 // CHECK-NEXT:         cir.scope {
 // CHECK-NEXT:           %5 = cir.const #cir.int<3> : !s32i
 // CHECK-NEXT:           cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:           %6 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:           %6 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:           cir.return %6 : !s32i
 // CHECK-NEXT:         }
 // CHECK-NEXT:         cir.yield
@@ -87,7 +87,7 @@ int sw4(int a) {
 // CHECK-NEXT:       cir.case(default, []) {
 // CHECK-NEXT:         %5 = cir.const #cir.int<2> : !s32i
 // CHECK-NEXT:         cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK-NEXT:         %6 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK-NEXT:         %6 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK-NEXT:         cir.return %6 : !s32i
 // CHECK-NEXT:       }
 // CHECK-NEXT:       cir.yield
diff --git a/clang/test/CIR/CodeGen/tbaa-bitinit.c b/clang/test/CIR/CodeGen/tbaa-bitinit.c
index cd32a63e237f..ca90bfc6e96e 100644
--- a/clang/test/CIR/CodeGen/tbaa-bitinit.c
+++ b/clang/test/CIR/CodeGen/tbaa-bitinit.c
@@ -10,7 +10,7 @@ _BitInt(33) a;
 _BitInt(31) b;
 void c() {
   // CIR-LABEL: cir.func {{.*}} @c()
-  // CIR: %{{.*}} = cir.load %{{.*}} : !cir.ptr<!cir.int<s, 33>>, !cir.int<s, 33> tbaa(#tbaa[[BitInt33]])
+  // CIR: %{{.*}} = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.int<s, 33>>, !cir.int<s, 33> tbaa(#tbaa[[BitInt33]])
   // CIR: cir.store{{.*}} %{{.*}}, %{{.*}} : !cir.int<s, 31>, !cir.ptr<!cir.int<s, 31>> tbaa(#tbaa[[BitInt31]])
 
   // LLVM-LABEL: define {{.*}} void @c()
diff --git a/clang/test/CIR/CodeGen/tbaa-enum.c b/clang/test/CIR/CodeGen/tbaa-enum.c
index f356bb0a3a88..61f0044ec545 100644
--- a/clang/test/CIR/CodeGen/tbaa-enum.c
+++ b/clang/test/CIR/CodeGen/tbaa-enum.c
@@ -49,14 +49,14 @@ uint32_t g0(EnumAuto32 *E, uint32_t *val) {
   // CIR-LABEL: cir.func @g0
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u32i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[INT]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !s32i
   // CIR: %[[U_C0:.*]] = cir.cast(integral, %[[C0]] : !s32i), !u32i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
   // CIR: cir.store{{.*}} %[[U_C0]], %[[E_PTR]] : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[INT]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u32i>, !u32i tbaa(#tbaa[[INT]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u32i>, !u32i tbaa(#tbaa[[INT]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u32i, !cir.ptr<!u32i>
 
   // LLVM-LABEL: define{{.*}} i32 @g0(
@@ -72,13 +72,13 @@ uint64_t g1(EnumAuto64 *E, uint64_t *val) {
   // CIR-LABEL: cir.func @g1
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u64i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u64i, !cir.ptr<!u64i> tbaa(#tbaa[[LONG_LONG]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u64i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u64i, !cir.ptr<!u64i> tbaa(#tbaa[[LONG]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u64i>, !u64i tbaa(#tbaa[[LONG_LONG]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u64i>, !u64i tbaa(#tbaa[[LONG_LONG]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u64i, !cir.ptr<!u64i>
 
   // LLVM-LABEL: define{{.*}} i64 @g1(
@@ -94,13 +94,13 @@ uint16_t g2(Enum16 *E, uint16_t *val) {
   // CIR-LABEL: cir.func @g2
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u16i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[SHORT]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u16i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[SHORT]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u16i>, !u16i tbaa(#tbaa[[SHORT]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u16i>, !u16i tbaa(#tbaa[[SHORT]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u16i, !cir.ptr<!u16i>
 
   // LLVM-LABEL: define{{.*}} i16 @g2(
@@ -116,13 +116,13 @@ uint8_t g3(Enum8 *E, uint8_t *val) {
   // CIR-LABEL: cir.func @g3
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u8i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u8i, !cir.ptr<!u8i> tbaa(#tbaa[[CHAR]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u8i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u8i, !cir.ptr<!u8i> tbaa(#tbaa[[CHAR]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u8i>, !u8i tbaa(#tbaa[[CHAR]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u8i>, !u8i tbaa(#tbaa[[CHAR]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u8i, !cir.ptr<!u8i>
   
 
diff --git a/clang/test/CIR/CodeGen/tbaa-enum.cpp b/clang/test/CIR/CodeGen/tbaa-enum.cpp
index bce894e04d24..5d8650c4ef6d 100644
--- a/clang/test/CIR/CodeGen/tbaa-enum.cpp
+++ b/clang/test/CIR/CodeGen/tbaa-enum.cpp
@@ -53,13 +53,13 @@ uint32_t g0(EnumAuto32 *E, uint32_t *val) {
   // CIR-LABEL: cir.func @_Z2g0
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u32i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[INT]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u32i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[EnumAuto32]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u32i>, !u32i tbaa(#tbaa[[INT]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u32i>>, !cir.ptr<!u32i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u32i>, !u32i tbaa(#tbaa[[INT]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u32i, !cir.ptr<!u32i>
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g0
@@ -75,13 +75,13 @@ uint64_t g1(EnumAuto64 *E, uint64_t *val) {
   // CIR-LABEL: cir.func @_Z2g1
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u64i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u64i, !cir.ptr<!u64i> tbaa(#tbaa[[LONG_LONG]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u64i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u64i, !cir.ptr<!u64i> tbaa(#tbaa[[EnumAuto64]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u64i>, !u64i tbaa(#tbaa[[LONG_LONG]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u64i>, !u64i tbaa(#tbaa[[LONG_LONG]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u64i, !cir.ptr<!u64i>
 
   // LLVM-LABEL: define{{.*}} i64 @_Z2g1
@@ -97,13 +97,13 @@ uint16_t g2(Enum16 *E, uint16_t *val) {
   // CIR-LABEL: cir.func @_Z2g2
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u16i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[SHORT]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u16i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[Enum16]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u16i>, !u16i tbaa(#tbaa[[SHORT]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u16i>>, !cir.ptr<!u16i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u16i>, !u16i tbaa(#tbaa[[SHORT]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u16i, !cir.ptr<!u16i>
 
   // LLVM-LABEL: define{{.*}} i16 @_Z2g2
@@ -119,13 +119,13 @@ uint8_t g3(Enum8 *E, uint8_t *val) {
   // CIR-LABEL: cir.func @_Z2g3
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
   // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u8i
-  // CIR: %[[VAL_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+  // CIR: %[[VAL_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
   // CIR: cir.store{{.*}} %[[U_C5]], %[[VAL_PTR]] : !u8i, !cir.ptr<!u8i> tbaa(#tbaa[[CHAR]])
   // CIR: %[[C0:.*]] = cir.const #cir.int<0> : !u8i
-  // CIR: %[[E_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+  // CIR: %[[E_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
   // CIR: cir.store{{.*}} %[[C0]], %[[E_PTR]] : !u8i, !cir.ptr<!u8i> tbaa(#tbaa[[Enum8]])
-  // CIR: %[[RET_PTR:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
-  // CIR: %[[RET:.*]] = cir.load %[[RET_PTR]] : !cir.ptr<!u8i>, !u8i tbaa(#tbaa[[CHAR]])
+  // CIR: %[[RET_PTR:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+  // CIR: %[[RET:.*]] = cir.load{{.*}} %[[RET_PTR]] : !cir.ptr<!u8i>, !u8i tbaa(#tbaa[[CHAR]])
   // CIR: cir.store{{.*}} %[[RET]], %{{.*}} : !u8i, !cir.ptr<!u8i>
   
 
diff --git a/clang/test/CIR/CodeGen/tbaa-pointer.cpp b/clang/test/CIR/CodeGen/tbaa-pointer.cpp
index d082f0751b9b..605038a73705 100644
--- a/clang/test/CIR/CodeGen/tbaa-pointer.cpp
+++ b/clang/test/CIR/CodeGen/tbaa-pointer.cpp
@@ -31,9 +31,9 @@ int test_scalar_pointer(int*** p3) {
     int t = *p1;
 
     // CIR-POINTER-TBAA-LABEL: _Z19test_scalar_pointerPPPi
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> tbaa(#tbaa[[p3_INT]])
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!s32i>> tbaa(#tbaa[[p2_INT]])
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i> tbaa(#tbaa[[p1_INT]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> tbaa(#tbaa[[p3_INT]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!s32i>> tbaa(#tbaa[[p2_INT]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i> tbaa(#tbaa[[p1_INT]])
 
     // LLVM-LABEL: _Z19test_scalar_pointerPPPi
     // LLVM: %[[p2:.*]] = load ptr, ptr %{{.*}}, align 8, !tbaa ![[TBAA_ANY_PTR:.*]]
@@ -59,9 +59,9 @@ int test_struct_pointer(A*** p3, int A::***m3) {
     p1 = *p2;
 
     // CIR-POINTER-TBAA-LABEL: _Z19test_struct_pointerPPP1APPMS_i
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_A>>>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_A>>> tbaa(#tbaa[[p3_STRUCT_A]])
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!rec_A>>>, !cir.ptr<!cir.ptr<!rec_A>> tbaa(#tbaa[[p2_STRUCT_A]])
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load %{{.*}} : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A> tbaa(#tbaa[[p1_STRUCT_A]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_A>>>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_A>>> tbaa(#tbaa[[p3_STRUCT_A]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!rec_A>>>, !cir.ptr<!cir.ptr<!rec_A>> tbaa(#tbaa[[p2_STRUCT_A]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A> tbaa(#tbaa[[p1_STRUCT_A]])
 
     // LLVM-LABEL: _Z19test_struct_pointerPPP1APPMS_i
     // LLVM: %[[p2:.*]] = load ptr, ptr %{{.*}}, align 8, !tbaa ![[TBAA_ANY_PTR]]
@@ -78,10 +78,10 @@ int test_struct_pointer(A*** p3, int A::***m3) {
 void test_member_pointer(A& a, int A::***m3, int val) {
 
     // CIR-LABEL: _Z19test_member_pointerR1APPMS_ii
-    // CIR: %{{.*}} = cir.load %{{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_A>>, !cir.data_member<!s32i in !rec_A> tbaa(#tbaa[[CHAR]])
+    // CIR: %{{.*}} = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_A>>, !cir.data_member<!s32i in !rec_A> tbaa(#tbaa[[CHAR]])
 
     // CIR-POINTER-TBAA-LABEL: _Z19test_member_pointerR1APPMS_ii
-    // CIR-POINTER-TBAA: %{{.*}} = cir.load %{{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_A>>, !cir.data_member<!s32i in !rec_A> tbaa(#tbaa[[CHAR]])
+    // CIR-POINTER-TBAA: %{{.*}} = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_A>>, !cir.data_member<!s32i in !rec_A> tbaa(#tbaa[[CHAR]])
 
     // LLVM-LABEL: _Z19test_member_pointerR1APPMS_ii
     // LLVM: %[[m2:.*]] = load ptr, ptr %{{.*}}, align 8, !tbaa ![[TBAA_ANY_PTR:.*]]
diff --git a/clang/test/CIR/CodeGen/tbaa-scalar.c b/clang/test/CIR/CodeGen/tbaa-scalar.c
index 5c67e0f15ea5..235293d03b09 100644
--- a/clang/test/CIR/CodeGen/tbaa-scalar.c
+++ b/clang/test/CIR/CodeGen/tbaa-scalar.c
@@ -20,15 +20,15 @@
 void test_int_and_float(int *a, float *b) {
   // CIR-LABEL: cir.func @test_int_and_float
   // CIR: cir.scope
-  // CIR: %[[TMP1:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-  // CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i tbaa(#tbaa[[INT]])
+  // CIR: %[[TMP1:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+  // CIR: %[[TMP2:.*]] = cir.load{{.*}} %[[TMP1]] : !cir.ptr<!s32i>, !s32i tbaa(#tbaa[[INT]])
   // CIR: cir.if
   // CIR: %[[C2:.*]] = cir.const #cir.fp<2
-  // CIR: %[[TMP3:.*]] = cir.load deref %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
+  // CIR: %[[TMP3:.*]] = cir.load deref{{.*}} %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
   // CIR: cir.store{{.*}} %[[C2]], %[[TMP3]] : !cir.float, !cir.ptr<!cir.float> tbaa(#tbaa[[FLOAT]])
   // CIR: else
   // CIR: %[[C3:.*]] = cir.const #cir.fp<3
-  // CIR: %[[TMP4:.*]] = cir.load deref %[[ARG_b]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
+  // CIR: %[[TMP4:.*]] = cir.load deref{{.*}} %[[ARG_b]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
   // CIR: cir.store{{.*}} %[[C3]], %[[TMP4]] : !cir.float, !cir.ptr<!cir.float> tbaa(#tbaa[[FLOAT]])
 
   // LLVM-LABEL: void @test_int_and_float
@@ -47,15 +47,15 @@ void test_int_and_float(int *a, float *b) {
 void test_long_and_double(long *a, double *b) {
   // CIR-LABEL: cir.func @test_long_and_double
   // CIR: cir.scope
-  // CIR: %[[TMP1:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
-  // CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s64i>, !s64i tbaa(#tbaa[[LONG]])
+  // CIR: %[[TMP1:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+  // CIR: %[[TMP2:.*]] = cir.load{{.*}} %[[TMP1]] : !cir.ptr<!s64i>, !s64i tbaa(#tbaa[[LONG]])
   // CIR: cir.if
   // CIR: %[[C2:.*]] = cir.const #cir.fp<2
-  // CIR: %[[TMP3:.*]] = cir.load deref %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!cir.double>>, !cir.ptr<!cir.double>
+  // CIR: %[[TMP3:.*]] = cir.load deref{{.*}} %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!cir.double>>, !cir.ptr<!cir.double>
   // CIR: cir.store{{.*}} %[[C2]], %[[TMP3]] : !cir.double, !cir.ptr<!cir.double> tbaa(#tbaa[[DOUBLE]])
   // CIR: else
   // CIR: %[[C3:.*]] = cir.const #cir.fp<3
-  // CIR: %[[TMP4:.*]] = cir.load deref %[[ARG_b]] : !cir.ptr<!cir.ptr<!cir.double>>, !cir.ptr<!cir.double>
+  // CIR: %[[TMP4:.*]] = cir.load deref{{.*}} %[[ARG_b]] : !cir.ptr<!cir.ptr<!cir.double>>, !cir.ptr<!cir.double>
   // CIR: cir.store{{.*}} %[[C3]], %[[TMP4]] : !cir.double, !cir.ptr<!cir.double> tbaa(#tbaa[[DOUBLE]])
 
   // LLVM-LABEL: void @test_long_and_double
@@ -73,15 +73,15 @@ void test_long_and_double(long *a, double *b) {
 void test_long_long_and_long_double(long long *a, long double *b) {
   // CIR-LABEL: cir.func @test_long_long_and_long_double
   // CIR: cir.scope
-  // CIR: %[[TMP1:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
-  // CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s64i>, !s64i tbaa(#tbaa[[LONG_LONG]])
+  // CIR: %[[TMP1:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!s64i>>, !cir.ptr<!s64i>
+  // CIR: %[[TMP2:.*]] = cir.load{{.*}} %[[TMP1]] : !cir.ptr<!s64i>, !s64i tbaa(#tbaa[[LONG_LONG]])
   // CIR: cir.if
   // CIR: %[[C2:.*]] = cir.const #cir.fp<2
-  // CIR: %[[TMP3:.*]] = cir.load deref %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!cir.long_double<!cir.f80>>>, !cir.ptr<!cir.long_double<!cir.f80>>
+  // CIR: %[[TMP3:.*]] = cir.load deref{{.*}} %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!cir.long_double<!cir.f80>>>, !cir.ptr<!cir.long_double<!cir.f80>>
   // CIR: cir.store{{.*}} %[[C2]], %[[TMP3]] : !cir.long_double<!cir.f80>, !cir.ptr<!cir.long_double<!cir.f80>> tbaa(#tbaa[[LONG_DOUBLE]])
   // CIR: else
   // CIR: %[[C3:.*]] = cir.const #cir.fp<3
-  // CIR: %[[TMP4:.*]] = cir.load deref %[[ARG_b]] : !cir.ptr<!cir.ptr<!cir.long_double<!cir.f80>>>, !cir.ptr<!cir.long_double<!cir.f80>>
+  // CIR: %[[TMP4:.*]] = cir.load deref{{.*}} %[[ARG_b]] : !cir.ptr<!cir.ptr<!cir.long_double<!cir.f80>>>, !cir.ptr<!cir.long_double<!cir.f80>>
   // CIR: cir.store{{.*}} %[[C3]], %[[TMP4]] : !cir.long_double<!cir.f80>, !cir.ptr<!cir.long_double<!cir.f80>> tbaa(#tbaa[[LONG_DOUBLE]])
 
   // LLVM-LABEL: void @test_long_long_and_long_double
@@ -100,17 +100,17 @@ void test_long_long_and_long_double(long long *a, long double *b) {
 void test_char(char *a, char* b) {
   // CIR-LABEL: cir.func @test_char
   // CIR: cir.scope
-  // CIR: %[[TMP1:.*]] = cir.load deref %{{.*}} : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
-  // CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s8i>, !s8i tbaa(#tbaa[[CHAR]])
+  // CIR: %[[TMP1:.*]] = cir.load deref{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+  // CIR: %[[TMP2:.*]] = cir.load{{.*}} %[[TMP1]] : !cir.ptr<!s8i>, !s8i tbaa(#tbaa[[CHAR]])
   // CIR: cir.if
   // CIR: %[[C2:.*]] = cir.const #cir.int<98> : !s32i
   // CIR: %[[C2_CHAR:.*]] = cir.cast(integral, %[[C2]] : !s32i), !s8i
-  // CIR: %[[TMP3:.*]] = cir.load deref %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+  // CIR: %[[TMP3:.*]] = cir.load deref{{.*}} %[[ARG_b:.*]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
   // CIR: cir.store{{.*}} %[[C2_CHAR]], %[[TMP3]] : !s8i, !cir.ptr<!s8i> tbaa(#tbaa[[CHAR]])
   // CIR: else
   // CIR: %[[C3:.*]] = cir.const #cir.int<0> : !s32i
   // CIR: %[[C3_CHAR:.*]] = cir.cast(integral, %[[C3]] : !s32i), !s8i
-  // CIR: %[[TMP4:.*]] = cir.load deref %[[ARG_b]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
+  // CIR: %[[TMP4:.*]] = cir.load deref{{.*}} %[[ARG_b]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
   // CIR: cir.store{{.*}} %[[C3_CHAR]], %[[TMP4]] : !s8i, !cir.ptr<!s8i> tbaa(#tbaa[[CHAR]])
 
 
diff --git a/clang/test/CIR/CodeGen/tbaa-struct.cpp b/clang/test/CIR/CodeGen/tbaa-struct.cpp
index be2428d9953d..e594f4c1b362 100644
--- a/clang/test/CIR/CodeGen/tbaa-struct.cpp
+++ b/clang/test/CIR/CodeGen/tbaa-struct.cpp
@@ -334,9 +334,9 @@ struct six {
 };
 char g14(struct six *a, struct six *b) {
   // CIR-LABEL: cir.func @_Z3g14
-  // CIR: %[[TMP1:.*]] = cir.load %{{.*}} : !cir.ptr<!cir.ptr<!rec_six>>, !cir.ptr<!rec_six>
+  // CIR: %[[TMP1:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!rec_six>>, !cir.ptr<!rec_six>
   // CIR: %[[TMP2:.*]] = cir.get_member %[[TMP1]][2] {name = "b"} : !cir.ptr<!rec_six> -> !cir.ptr<!s8i>
-  // CIR: %[[TMP3:.*]] = cir.load %[[TMP2]] : !cir.ptr<!s8i>, !s8i tbaa(#tbaa[[TAG_six_b]])
+  // CIR: %[[TMP3:.*]] = cir.load{{.*}} %[[TMP2]] : !cir.ptr<!s8i>, !s8i tbaa(#tbaa[[TAG_six_b]])
 
   // LLVM-LABEL: define{{.*}} i8 @_Z3g14
   // LLVM: load i8, ptr %{{.*}}, align 1, !tbaa [[TAG_char]]
diff --git a/clang/test/CIR/CodeGen/tbaa-union.c b/clang/test/CIR/CodeGen/tbaa-union.c
index 0f5696c3f342..d2a5c3abf785 100644
--- a/clang/test/CIR/CodeGen/tbaa-union.c
+++ b/clang/test/CIR/CodeGen/tbaa-union.c
@@ -19,7 +19,7 @@ typedef struct {
 void foo(S *s) {
   // CIR-LABEL: cir.func @foo
   // CIR: %[[C1:.*]] = cir.const #cir.int<1> : !s32i loc(#loc6)
-  // CIR: %{{.*}} = cir.load %{{.*}} : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
+  // CIR: %{{.*}} = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
   // CIR: cir.store{{.*}} %[[C1]], %{{.*}} : !s32i, !cir.ptr<!s32i> tbaa(#tbaa[[CHAR]])
 
   // LLVM-LABEL: void @foo
diff --git a/clang/test/CIR/CodeGen/ternary.cpp b/clang/test/CIR/CodeGen/ternary.cpp
index 3e5fec924a15..a19b42cabeb1 100644
--- a/clang/test/CIR/CodeGen/ternary.cpp
+++ b/clang/test/CIR/CodeGen/ternary.cpp
@@ -9,14 +9,14 @@ int x(int y) {
 // CHECK:     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
 // CHECK:     %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK:     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
-// CHECK:     %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // CHECK:     %3 = cir.const #cir.int<0> : !s32i
 // CHECK:     %4 = cir.cmp(gt, %2, %3) : !s32i, !cir.bool
 // CHECK:     %5 = cir.const #cir.int<3> : !s32i
 // CHECK:     %6 = cir.const #cir.int<5> : !s32i
 // CHECK:     %7 = cir.select if %4 then %5 else %6 : (!cir.bool, !s32i, !s32i) -> !s32i
 // CHECK:     cir.store %7, %1 : !s32i, !cir.ptr<!s32i>
-// CHECK:     %8 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// CHECK:     %8 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // CHECK:     cir.return %8 : !s32i
 // CHECK:   }
 
@@ -34,7 +34,7 @@ void m(APIType api) {
 // CHECK:  cir.func @_Z1m7APIType
 // CHECK:    %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["api", init] {alignment = 4 : i64}
 // CHECK:    cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
-// CHECK:    %1 = cir.load %0 : !cir.ptr<!u32i>, !u32i
+// CHECK:    %1 = cir.load{{.*}} %0 : !cir.ptr<!u32i>, !u32i
 // CHECK:    %2 = cir.cast(integral, %1 : !u32i), !s32i
 // CHECK:    %3 = cir.const #cir.int<0> : !u32i
 // CHECK:    %4 = cir.cast(integral, %3 : !u32i), !s32i
@@ -58,14 +58,14 @@ int foo(int a, int b) {
 }
 
 // CHECK:  cir.func @_Z3fooii
-// CHECK:   [[A0:%.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
-// CHECK:   [[B0:%.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK:   [[A0:%.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK:   [[B0:%.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK:   [[CMP:%.*]] = cir.cmp(lt, [[A0]], [[B0]]) : !s32i, !cir.bool
 // CHECK:   [[RES:%.*]] = cir.ternary([[CMP]], true {
 // CHECK:     [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:     cir.yield [[ZERO]] : !s32i
 // CHECK:   }, false {
-// CHECK:     [[A1:%.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK:     [[A1:%.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK:     cir.yield [[A1]] : !s32i
 // CHECK:   }) : (!cir.bool) -> !s32i
 // CHECK:   [[RES_CAST:%.*]] = cir.cast(int_to_bool, [[RES]] : !s32i), !cir.bool
@@ -84,14 +84,14 @@ bool func(bool a, bool b) {
 // CHECK:    cir.store [[ARG_A]], [[ALLOC_A]] : !cir.bool, !cir.ptr<!cir.bool>
 // CHECK:    cir.store [[ARG_B]], [[ALLOC_B]] : !cir.bool, !cir.ptr<!cir.bool>
 // CHECK:    cir.call @_Z22maybe_has_side_effectsv() : () -> ()
-// CHECK:    [[A0:%.*]] = cir.load [[ALLOC_A]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:    [[A0:%.*]] = cir.load{{.*}} [[ALLOC_A]] : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK:    [[RES:%.*]] = cir.ternary([[A0]], true {
-// CHECK:      [[A1:%.*]] = cir.load [[ALLOC_A]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:      [[A1:%.*]] = cir.load{{.*}} [[ALLOC_A]] : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK:      cir.yield [[A1]] : !cir.bool
 // CHECK:    }, false {
-// CHECK:      [[B0:%.*]] = cir.load [[ALLOC_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:      [[B0:%.*]] = cir.load{{.*}} [[ALLOC_B]] : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK:      cir.yield [[B0]] : !cir.bool
 // CHECK:    }) : (!cir.bool) -> !cir.bool
 // CHECK:    cir.store [[RES]], [[ALLOC_RET]] : !cir.bool, !cir.ptr<!cir.bool>
-// CHECK:    [[R:%.*]] = cir.load [[ALLOC_RET]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK:    [[R:%.*]] = cir.load{{.*}} [[ALLOC_RET]] : !cir.ptr<!cir.bool>, !cir.bool
 // CHECK:    cir.return [[R]] : !cir.bool
diff --git a/clang/test/CIR/CodeGen/three-way-comparison.cpp b/clang/test/CIR/CodeGen/three-way-comparison.cpp
index 3936fe63cbb0..1d62fd58ab17 100644
--- a/clang/test/CIR/CodeGen/three-way-comparison.cpp
+++ b/clang/test/CIR/CodeGen/three-way-comparison.cpp
@@ -53,8 +53,8 @@ auto three_way_weak(float x, float y) {
 // BEFORE: }
 
 //      AFTER: cir.func @_Z14three_way_weakff
-//      AFTER:   %[[#LHS:]] = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
-// AFTER-NEXT:   %[[#RHS:]] = cir.load %1 : !cir.ptr<!cir.float>, !cir.float
+//      AFTER:   %[[#LHS:]] = cir.load{{.*}} %0 : !cir.ptr<!cir.float>, !cir.float
+// AFTER-NEXT:   %[[#RHS:]] = cir.load{{.*}} %1 : !cir.ptr<!cir.float>, !cir.float
 // AFTER-NEXT:   %[[#LT:]] = cir.const #cir.int<-1> : !s8i
 // AFTER-NEXT:   %[[#EQ:]] = cir.const #cir.int<0> : !s8i
 // AFTER-NEXT:   %[[#GT:]] = cir.const #cir.int<1> : !s8i
diff --git a/clang/test/CIR/CodeGen/throw.cpp b/clang/test/CIR/CodeGen/throw.cpp
index c97b3ed86819..dd644a96ae24 100644
--- a/clang/test/CIR/CodeGen/throw.cpp
+++ b/clang/test/CIR/CodeGen/throw.cpp
@@ -51,7 +51,7 @@ void refoo1() {
 // CIR:       cir.yield
 // CIR:     } catch [type #cir.all {
 // CIR:       %[[V3:.*]] = cir.catch_param -> !cir.ptr<!void>
-// CIR:       %[[V4:.*]] = cir.load %[[V0]] : !cir.ptr<!s32i>, !s32i
+// CIR:       %[[V4:.*]] = cir.load{{.*}} %[[V0]] : !cir.ptr<!s32i>, !s32i
 // CIR:       %[[V5:.*]] = cir.unary(inc, %[[V4]]) nsw : !s32i, !s32i
 // CIR:       cir.store{{.*}} %[[V5]], %[[V0]] : !s32i, !cir.ptr<!s32i>
 // CIR:       cir.yield
@@ -120,7 +120,7 @@ void refoo2() {
 // CIR:         %[[V4:.*]] = cir.const #cir.int<0> : !s32i
 // CIR:         cir.store{{.*}} %[[V4]], %[[V3]] : !s32i, !cir.ptr<!s32i>
 // CIR:         cir.for : cond {
-// CIR:           %[[V5:.*]] = cir.load %[[V3]] : !cir.ptr<!s32i>, !s32i
+// CIR:           %[[V5:.*]] = cir.load{{.*}} %[[V3]] : !cir.ptr<!s32i>, !s32i
 // CIR:           %[[V6:.*]] = cir.const #cir.int<5> : !s32i
 // CIR:           %[[V7:.*]] = cir.cmp(lt, %[[V5]], %[[V6]]) : !s32i, !cir.bool
 // CIR:           cir.condition(%[[V7]])
@@ -135,7 +135,7 @@ void refoo2() {
 // CIR:           }
 // CIR:           cir.yield
 // CIR:         } step {
-// CIR:           %[[V5:.*]] = cir.load %[[V3]] : !cir.ptr<!s32i>, !s32i
+// CIR:           %[[V5:.*]] = cir.load{{.*}} %[[V3]] : !cir.ptr<!s32i>, !s32i
 // CIR:           %[[V6:.*]] = cir.unary(inc, %[[V5]]) nsw : !s32i, !s32i
 // CIR:           cir.store{{.*}} %[[V6]], %[[V3]] : !s32i, !cir.ptr<!s32i>
 // CIR:           cir.yield
@@ -145,7 +145,7 @@ void refoo2() {
 // CIR:       cir.yield
 // CIR:     } catch [type #cir.all {
 // CIR:       %[[V3:.*]] = cir.catch_param -> !cir.ptr<!void>
-// CIR:       %[[V4:.*]] = cir.load %[[V0]] : !cir.ptr<!s32i>, !s32i
+// CIR:       %[[V4:.*]] = cir.load{{.*}} %[[V0]] : !cir.ptr<!s32i>, !s32i
 // CIR:       %[[V5:.*]] = cir.unary(inc, %[[V4]]) nsw : !s32i, !s32i
 // CIR:       cir.store{{.*}} %[[V5]], %[[V0]] : !s32i, !cir.ptr<!s32i>
 // CIR:       cir.yield
@@ -227,7 +227,7 @@ void refoo3() {
 // CIR:       cir.yield
 // CIR:     } catch [type #cir.all {
 // CIR:       %[[V3:.*]] = cir.catch_param -> !cir.ptr<!void>
-// CIR:       %[[V4:.*]] = cir.load %[[V0]] : !cir.ptr<!s32i>, !s32i
+// CIR:       %[[V4:.*]] = cir.load{{.*}} %[[V0]] : !cir.ptr<!s32i>, !s32i
 // CIR:       %[[V5:.*]] = cir.unary(inc, %[[V4]]) nsw : !s32i, !s32i
 // CIR:       cir.store{{.*}} %[[V5]], %[[V0]] : !s32i, !cir.ptr<!s32i>
 // CIR:       cir.yield
diff --git a/clang/test/CIR/CodeGen/try-catch-dtors.cpp b/clang/test/CIR/CodeGen/try-catch-dtors.cpp
index 044a1fe1b785..cad3558b912d 100644
--- a/clang/test/CIR/CodeGen/try-catch-dtors.cpp
+++ b/clang/test/CIR/CodeGen/try-catch-dtors.cpp
@@ -335,7 +335,7 @@ void bar() {
 // CIR:  } catch [#cir.unwind {
 // CIR:    cir.resume
 // CIR:  }]
-// CIR:  %[[V3:.*]] = cir.load %[[V2]] : !cir.ptr<!s32i>, !s32i
+// CIR:  %[[V3:.*]] = cir.load{{.*}} %[[V2]] : !cir.ptr<!s32i>, !s32i
 // CIR:  cir.store{{.*}} %[[V3]], %[[V1]] : !s32i, !cir.ptr<!s32i>
 // CIR:  cir.call @_ZN1AD2Ev(%[[V0]]) : (!cir.ptr<!rec_A>) -> () extra(#fn_attr)
 // CIR:  cir.return
@@ -356,7 +356,7 @@ void d() {
 // CIR: cir.scope {
 // CIR:   %[[V2:.*]] = cir.alloca !rec_C, !cir.ptr<!rec_C>, ["agg.tmp0"] {alignment = 1 : i64}
 // CIR:   cir.call @_ZN1CC2ERKS_(%[[V2]], %[[V1]]) : (!cir.ptr<!rec_C>, !cir.ptr<!rec_C>) -> () extra(#fn_attr)
-// CIR:   %[[V3:.*]] = cir.load %[[V2]] : !cir.ptr<!rec_C>, !rec_C
+// CIR:   %[[V3:.*]] = cir.load{{.*}} %[[V2]] : !cir.ptr<!rec_C>, !rec_C
 // CIR:   cir.try synthetic cleanup {
 // CIR:     cir.call exception @_ZN1CaSES_(%[[V0]], %[[V3]]) : (!cir.ptr<!rec_C>, !rec_C) -> () cleanup {
 // CIR:       cir.call @_ZN1CD1Ev(%[[V2]]) : (!cir.ptr<!rec_C>) -> () extra(#fn_attr)
diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp
index 7a7686c8ee4c..0b2c166cda46 100644
--- a/clang/test/CIR/CodeGen/try-catch.cpp
+++ b/clang/test/CIR/CodeGen/try-catch.cpp
@@ -23,7 +23,7 @@ unsigned long long tc() {
   } catch (int idx) {
     // CHECK: } catch [type #cir.global_view<@_ZTIi> : !cir.ptr<!u8i> {
     // CHECK:   %[[catch_idx_addr:.*]] = cir.catch_param -> !cir.ptr<!s32i>
-    // CHECK:   %[[idx_load:.*]] = cir.load %[[catch_idx_addr]] : !cir.ptr<!s32i>, !s32i
+    // CHECK:   %[[idx_load:.*]] = cir.load{{.*}} %[[catch_idx_addr]] : !cir.ptr<!s32i>, !s32i
     // CHECK:   cir.store{{.*}} %[[idx_load]], %[[idx]] : !s32i, !cir.ptr<!s32i>
     z = 98;
     idx++;
@@ -143,7 +143,7 @@ void tc6() {
 // CHECK:   cir.try {
 // CHECK:     cir.return
 // CHECK:   ^bb1:  // no predecessors
-// CHECK:     %[[V2:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[V2:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK:     %[[V3:.*]] = cir.unary(inc, %[[V2]]) nsw : !s32i, !s32i
 // CHECK:     cir.store{{.*}} %[[V3]], {{.*}} : !s32i, !cir.ptr<!s32i>
 // CHECK:     cir.yield
@@ -162,7 +162,7 @@ void tc7() {
 
 // CHECK: cir.scope {
 // CHECK:   cir.try {
-// CHECK:     %[[V2:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CHECK:     %[[V2:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
 // CHECK:     %[[V3:.*]] = cir.unary(inc, %[[V2]]) nsw : !s32i, !s32i
 // CHECK:     cir.store{{.*}} %[[V3]], {{.*}} : !s32i, !cir.ptr<!s32i>
 // CHECK:     cir.return
diff --git a/clang/test/CIR/CodeGen/types-IEEE-quad.c b/clang/test/CIR/CodeGen/types-IEEE-quad.c
index 607374ef0407..9279a3584ecd 100644
--- a/clang/test/CIR/CodeGen/types-IEEE-quad.c
+++ b/clang/test/CIR/CodeGen/types-IEEE-quad.c
@@ -13,12 +13,12 @@ long double t2(long double i2) {
 // CIR-NEXT:    %[[#I2:]] = cir.alloca !cir.long_double<!cir.f128>, !cir.ptr<!cir.long_double<!cir.f128>>, ["i2", init] {alignment = 16 : i64}
 // CIR-NEXT:    %[[#RETVAL:]] = cir.alloca !cir.long_double<!cir.f128>, !cir.ptr<!cir.long_double<!cir.f128>>, ["__retval"] {alignment = 16 : i64}
 // CIR-NEXT:    cir.store %arg0, %[[#I2]] : !cir.long_double<!cir.f128>, !cir.ptr<!cir.long_double<!cir.f128>>
-// CIR-NEXT:    %[[#I2_LOAD:]] = cir.load %[[#I2]] : !cir.ptr<!cir.long_double<!cir.f128>>, !cir.long_double<!cir.f128>
+// CIR-NEXT:    %[[#I2_LOAD:]] = cir.load{{.*}} %[[#I2]] : !cir.ptr<!cir.long_double<!cir.f128>>, !cir.long_double<!cir.f128>
 // CIR-NEXT:    %[[#I:]] = cir.get_global @i : !cir.ptr<!cir.long_double<!cir.f128>>
-// CIR-NEXT:    %[[#I_LOAD:]] = cir.load %[[#I]] : !cir.ptr<!cir.long_double<!cir.f128>>, !cir.long_double<!cir.f128>
+// CIR-NEXT:    %[[#I_LOAD:]] = cir.load{{.*}} %[[#I]] : !cir.ptr<!cir.long_double<!cir.f128>>, !cir.long_double<!cir.f128>
 // CIR-NEXT:    %[[#ADD:]] = cir.binop(add, %[[#I2_LOAD]], %[[#I_LOAD]]) : !cir.long_double<!cir.f128>
 // CIR-NEXT:    cir.store %[[#ADD]], %[[#RETVAL]] : !cir.long_double<!cir.f128>, !cir.ptr<!cir.long_double<!cir.f128>>
-// CIR-NEXT:    %[[#RETVAL_LOAD:]] = cir.load %[[#RETVAL]] : !cir.ptr<!cir.long_double<!cir.f128>>, !cir.long_double<!cir.f128>
+// CIR-NEXT:    %[[#RETVAL_LOAD:]] = cir.load{{.*}} %[[#RETVAL]] : !cir.ptr<!cir.long_double<!cir.f128>>, !cir.long_double<!cir.f128>
 // CIR-NEXT:    cir.return %[[#RETVAL_LOAD]] : !cir.long_double<!cir.f128>
 
 //LLVM:         @i = global fp128 0xL00000000000000000000000000000000, align 16
diff --git a/clang/test/CIR/CodeGen/unary-deref.cpp b/clang/test/CIR/CodeGen/unary-deref.cpp
index 665fc4bca0fe..f2d809445814 100644
--- a/clang/test/CIR/CodeGen/unary-deref.cpp
+++ b/clang/test/CIR/CodeGen/unary-deref.cpp
@@ -11,7 +11,7 @@ void foo() {
 }
 
 // CHECK:  cir.func linkonce_odr @_ZNK12MyIntPointer4readEv
-// CHECK:  %2 = cir.load %0
+// CHECK:  %2 = cir.load{{.*}} %0
 // CHECK:  %3 = cir.get_member %2[0] {name = "ptr"}
-// CHECK:  %4 = cir.load deref %3 : !cir.ptr<!cir.ptr<!s32i>>
-// CHECK:  %5 = cir.load %4
\ No newline at end of file
+// CHECK:  %4 = cir.load deref{{.*}} %3 : !cir.ptr<!cir.ptr<!s32i>>
+// CHECK:  %5 = cir.load{{.*}} %4
diff --git a/clang/test/CIR/CodeGen/unary.c b/clang/test/CIR/CodeGen/unary.c
index 63f355c09f45..6c6c4bce7106 100644
--- a/clang/test/CIR/CodeGen/unary.c
+++ b/clang/test/CIR/CodeGen/unary.c
@@ -4,7 +4,7 @@
 int valueNegationInt(int i) {
 // CHECK: cir.func @valueNegationInt(
   return !i;
-  // CHECK: %[[#INT:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s32i>, !s32i
+  // CHECK: %[[#INT:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s32i>, !s32i
   // CHECK: %[[#INT_TO_BOOL:]] = cir.cast(int_to_bool, %[[#INT]] : !s32i), !cir.bool
   // CHECK: = cir.unary(not, %[[#INT_TO_BOOL]]) : !cir.bool, !cir.bool
 }
@@ -12,7 +12,7 @@ int valueNegationInt(int i) {
 short valueNegationShort(short s) {
 // CHECK: cir.func @valueNegationShort(
   return !s;
-  // CHECK: %[[#SHORT:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s16i>, !s16i
+  // CHECK: %[[#SHORT:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s16i>, !s16i
   // CHECK: %[[#SHORT_TO_BOOL:]] = cir.cast(int_to_bool, %[[#SHORT]] : !s16i), !cir.bool
   // CHECK: = cir.unary(not, %[[#SHORT_TO_BOOL]]) : !cir.bool, !cir.bool
 }
@@ -20,7 +20,7 @@ short valueNegationShort(short s) {
 long valueNegationLong(long l) {
 // CHECK: cir.func @valueNegationLong(
   return !l;
-  // CHECK: %[[#LONG:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
+  // CHECK: %[[#LONG:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
   // CHECK: %[[#LONG_TO_BOOL:]] = cir.cast(int_to_bool, %[[#LONG]] : !s64i), !cir.bool
   // CHECK: = cir.unary(not, %[[#LONG_TO_BOOL]]) : !cir.bool, !cir.bool
 }
@@ -28,7 +28,7 @@ long valueNegationLong(long l) {
 float valueNegationFloat(float f) {
 // CHECK: cir.func @valueNegationFloat(
   return !f;
-  // CHECK: %[[#FLOAT:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.float>, !cir.float
+  // CHECK: %[[#FLOAT:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.float>, !cir.float
   // CHECK: %[[#FLOAT_TO_BOOL:]] = cir.cast(float_to_bool, %[[#FLOAT]] : !cir.float), !cir.bool
   // CHECK: %[[#FLOAT_NOT:]] = cir.unary(not, %[[#FLOAT_TO_BOOL]]) : !cir.bool, !cir.bool
   // CHECK: = cir.cast(bool_to_int, %[[#FLOAT_NOT]] : !cir.bool), !s32i
@@ -37,7 +37,7 @@ float valueNegationFloat(float f) {
 double valueNegationDouble(double d) {
 // CHECK: cir.func @valueNegationDouble(
   return !d;
-  // CHECK: %[[#DOUBLE:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.double>, !cir.double
+  // CHECK: %[[#DOUBLE:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.double>, !cir.double
   // CHECK: %[[#DOUBLE_TO_BOOL:]] = cir.cast(float_to_bool, %[[#DOUBLE]] : !cir.double), !cir.bool
   // CHECK: %[[#DOUBLE_NOT:]] = cir.unary(not, %[[#DOUBLE_TO_BOOL]]) : !cir.bool, !cir.bool
   // CHECK: = cir.cast(bool_to_int, %[[#DOUBLE_NOT]] : !cir.bool), !s32i
diff --git a/clang/test/CIR/CodeGen/unary.cpp b/clang/test/CIR/CodeGen/unary.cpp
index 7833d6d3c05e..643e220a1041 100644
--- a/clang/test/CIR/CodeGen/unary.cpp
+++ b/clang/test/CIR/CodeGen/unary.cpp
@@ -9,7 +9,7 @@ unsigned up0() {
 // CHECK: cir.func @_Z3up0v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#OUTPUT:]] = cir.unary(plus, %[[#INPUT]])
 // CHECK: cir.store{{.*}} %[[#OUTPUT]], %[[#RET]]
 
@@ -21,7 +21,7 @@ unsigned um0() {
 // CHECK: cir.func @_Z3um0v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#OUTPUT:]] = cir.unary(minus, %[[#INPUT]])
 // CHECK: cir.store{{.*}} %[[#OUTPUT]], %[[#RET]]
 
@@ -33,7 +33,7 @@ unsigned un0() {
 // CHECK: cir.func @_Z3un0v() -> !u32i
 // CHECK: %[[#RET:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"]
 // CHECK: %[[#A:]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#OUTPUT:]] = cir.unary(not, %[[#INPUT]])
 // CHECK: cir.store{{.*}} %[[#OUTPUT]], %[[#RET]]
 
@@ -48,12 +48,12 @@ int inc0() {
 // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
 // CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i
 // CHECK: cir.store{{.*}} %[[#ATMP]], %[[#A]] : !s32i
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#INCREMENTED:]] = cir.unary(inc, %[[#INPUT]]) nsw
 // CHECK: cir.store{{.*}} %[[#INCREMENTED]], %[[#A]]
-// CHECK: %[[#A_TO_OUTPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#A_TO_OUTPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: cir.store{{.*}} %[[#A_TO_OUTPUT]], %[[#RET]]
-// CHECK: %[[#OUTPUT:]] = cir.load %[[#RET]]
+// CHECK: %[[#OUTPUT:]] = cir.load{{.*}} %[[#RET]]
 // CHECK: cir.return %[[#OUTPUT]] : !s32i
 
 int dec0() {
@@ -67,12 +67,12 @@ int dec0() {
 // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
 // CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i
 // CHECK: cir.store{{.*}} %[[#ATMP]], %[[#A]] : !s32i
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#INCREMENTED:]] = cir.unary(dec, %[[#INPUT]]) nsw
 // CHECK: cir.store{{.*}} %[[#INCREMENTED]], %[[#A]]
-// CHECK: %[[#A_TO_OUTPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#A_TO_OUTPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: cir.store{{.*}} %[[#A_TO_OUTPUT]], %[[#RET]]
-// CHECK: %[[#OUTPUT:]] = cir.load %[[#RET]]
+// CHECK: %[[#OUTPUT:]] = cir.load{{.*}} %[[#RET]]
 // CHECK: cir.return %[[#OUTPUT]] : !s32i
 
 
@@ -87,12 +87,12 @@ int inc1() {
 // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
 // CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i
 // CHECK: cir.store{{.*}} %[[#ATMP]], %[[#A]] : !s32i
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#INCREMENTED:]] = cir.unary(inc, %[[#INPUT]]) nsw
 // CHECK: cir.store{{.*}} %[[#INCREMENTED]], %[[#A]]
-// CHECK: %[[#A_TO_OUTPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#A_TO_OUTPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: cir.store{{.*}} %[[#A_TO_OUTPUT]], %[[#RET]]
-// CHECK: %[[#OUTPUT:]] = cir.load %[[#RET]]
+// CHECK: %[[#OUTPUT:]] = cir.load{{.*}} %[[#RET]]
 // CHECK: cir.return %[[#OUTPUT]] : !s32i
 
 int dec1() {
@@ -106,12 +106,12 @@ int dec1() {
 // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
 // CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i
 // CHECK: cir.store{{.*}} %[[#ATMP]], %[[#A]] : !s32i
-// CHECK: %[[#INPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#INPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#INCREMENTED:]] = cir.unary(dec, %[[#INPUT]]) nsw
 // CHECK: cir.store{{.*}} %[[#INCREMENTED]], %[[#A]]
-// CHECK: %[[#A_TO_OUTPUT:]] = cir.load %[[#A]]
+// CHECK: %[[#A_TO_OUTPUT:]] = cir.load{{.*}} %[[#A]]
 // CHECK: cir.store{{.*}} %[[#A_TO_OUTPUT]], %[[#RET]]
-// CHECK: %[[#OUTPUT:]] = cir.load %[[#RET]]
+// CHECK: %[[#OUTPUT:]] = cir.load{{.*}} %[[#RET]]
 // CHECK: cir.return %[[#OUTPUT]] : !s32i
 
 // Ensure the increment is performed after the assignment to b.
@@ -127,13 +127,13 @@ int inc2() {
 // CHECK: %[[#B:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
 // CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i
 // CHECK: cir.store{{.*}} %[[#ATMP]], %[[#A]] : !s32i
-// CHECK: %[[#ATOB:]] = cir.load %[[#A]]
+// CHECK: %[[#ATOB:]] = cir.load{{.*}} %[[#A]]
 // CHECK: %[[#INCREMENTED:]] = cir.unary(inc, %[[#ATOB]]) nsw
 // CHECK: cir.store{{.*}} %[[#INCREMENTED]], %[[#A]]
 // CHECK: cir.store{{.*}} %[[#ATOB]], %[[#B]]
-// CHECK: %[[#B_TO_OUTPUT:]] = cir.load %[[#B]]
+// CHECK: %[[#B_TO_OUTPUT:]] = cir.load{{.*}} %[[#B]]
 // CHECK: cir.store{{.*}} %[[#B_TO_OUTPUT]], %[[#RET]]
-// CHECK: %[[#OUTPUT:]] = cir.load %[[#RET]]
+// CHECK: %[[#OUTPUT:]] = cir.load{{.*}} %[[#RET]]
 // CHECK: cir.return %[[#OUTPUT]] : !s32i
 
 int *inc_p(int *i) {
@@ -145,11 +145,11 @@ int *inc_p(int *i) {
 // CHECK: cir.func @_Z5inc_pPi(%arg0: !cir.ptr<!s32i>
 
 // CHECK:   %[[#i_addr:]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["i", init] {alignment = 8 : i64}
-// CHECK:   %[[#i_dec:]] = cir.load %[[#i_addr]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:   %[[#i_dec:]] = cir.load{{.*}} %[[#i_addr]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:   %[[#dec_const:]] = cir.const #cir.int<-1> : !s32i
 // CHECK:   = cir.ptr_stride(%[[#i_dec]] : !cir.ptr<!s32i>, %[[#dec_const]] : !s32i), !cir.ptr<!s32i>
 
-// CHECK:   %[[#i_inc:]] = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// CHECK:   %[[#i_inc:]] = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:   %[[#inc_const:]] = cir.const #cir.int<1> : !s32i
 // CHECK:   = cir.ptr_stride(%[[#i_inc]] : !cir.ptr<!s32i>, %[[#inc_const]] : !s32i), !cir.ptr<!s32i>
 
diff --git a/clang/test/CIR/CodeGen/union-init.c b/clang/test/CIR/CodeGen/union-init.c
index b3075f135c21..55380e063109 100644
--- a/clang/test/CIR/CodeGen/union-init.c
+++ b/clang/test/CIR/CodeGen/union-init.c
@@ -24,7 +24,7 @@ void foo(int x) {
 // CHECK:  cir.store{{.*}} {{.*}}, %[[VAL_1]] : !s32i, !cir.ptr<!s32i>
 // CHECK:  %[[VAL_3:.*]] = cir.get_member %[[VAL_2]][1] {name = ""} : !cir.ptr<!rec_A> -> !cir.ptr<!rec_anon2E0>
 // CHECK:  %[[VAL_4:.*]] = cir.cast(bitcast, %[[VAL_3]] : !cir.ptr<!rec_anon2E0>), !cir.ptr<!u32i>
-// CHECK:  %[[VAL_5:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!s32i>, !s32i
+// CHECK:  %[[VAL_5:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!s32i>, !s32i
 // CHECK:  %[[VAL_6:.*]] = cir.set_bitfield(#[[bfi_x]], %[[VAL_4]] : !cir.ptr<!u32i>, %[[VAL_5]] : !s32i) -> !s32i
 // CHECK:  %[[VAL_7:.*]] = cir.cast(bitcast, %[[VAL_3]] : !cir.ptr<!rec_anon2E0>), !cir.ptr<!u32i>
 // CHECK:  %[[VAL_8:.*]] = cir.const #cir.int<0> : !s32i
@@ -55,7 +55,7 @@ typedef union {
 // CHECK: %[[VAL_1:.*]] = cir.alloca !rec_U, !cir.ptr<!rec_U>, ["u", init] {alignment = 4 : i64}
 // CHECK: cir.store{{.*}} %arg0, %[[VAL_0]] : !s32i, !cir.ptr<!s32i>
 // CHECK: %[[VAL_2:.*]] = cir.cast(bitcast, %[[VAL_1]] : !cir.ptr<!rec_U>), !cir.ptr<!s32i>
-// CHECK: %[[VAL_3:.*]] = cir.load %[[VAL_0]] : !cir.ptr<!s32i>, !s32i
+// CHECK: %[[VAL_3:.*]] = cir.load{{.*}} %[[VAL_0]] : !cir.ptr<!s32i>, !s32i
 // CHECK: cir.store{{.*}} %[[VAL_3]], %[[VAL_2]] : !s32i, !cir.ptr<!s32i>
 
 void union_cast(int x) {
diff --git a/clang/test/CIR/CodeGen/var-arg-float.c b/clang/test/CIR/CodeGen/var-arg-float.c
index d11e10dccd5f..8132416a257a 100644
--- a/clang/test/CIR/CodeGen/var-arg-float.c
+++ b/clang/test/CIR/CodeGen/var-arg-float.c
@@ -21,9 +21,9 @@ double f1(int n, ...) {
 // BEFORE:  [[TMP0:%.*]] = cir.va.arg [[VARLIST]] : (!cir.ptr<!rec___va_list>) -> !cir.double
 // BEFORE:  cir.store{{.*}} [[TMP0]], [[RESP]] : !cir.double, !cir.ptr<!cir.double>
 // BEFORE:  cir.va.end [[VARLIST]] : !cir.ptr<!rec___va_list>
-// BEFORE:  [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!cir.double>, !cir.double
+// BEFORE:  [[RES:%.*]] = cir.load{{.*}} [[RESP]] : !cir.ptr<!cir.double>, !cir.double
 // BEFORE:   cir.store{{.*}} [[RES]], [[RETP]] : !cir.double, !cir.ptr<!cir.double>
-// BEFORE:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!cir.double>, !cir.double
+// BEFORE:  [[RETV:%.*]] = cir.load{{.*}} [[RETP]] : !cir.ptr<!cir.double>, !cir.double
 // BEFORE:   cir.return [[RETV]] : !cir.double
 
 // beginning block cir code
@@ -33,7 +33,7 @@ double f1(int n, ...) {
 // AFTER:  [[RESP:%.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["res", init]
 // AFTER:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!rec___va_list>
 // AFTER:  [[VR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][4] {name = "vr_offs"} : !cir.ptr<!rec___va_list> -> !cir.ptr<!s32i>
-// AFTER:  [[VR_OFFS:%.*]] = cir.load [[VR_OFFS_P]] : !cir.ptr<!s32i>, !s32i
+// AFTER:  [[VR_OFFS:%.*]] = cir.load{{.*}} [[VR_OFFS_P]] : !cir.ptr<!s32i>, !s32i
 // AFTER:  [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
 // AFTER:  [[CMP0:%.*]] = cir.cmp(ge, [[VR_OFFS]], [[ZERO]]) : !s32i, !cir.bool
 // AFTER-NEXT:  cir.brcond [[CMP0]] [[BB_ON_STACK:\^bb.*]], [[BB_MAY_REG:\^bb.*]]
@@ -48,7 +48,7 @@ double f1(int n, ...) {
 
 // AFTER: [[BB_IN_REG]]:
 // AFTER-NEXT: [[VR_TOP_P:%.*]] = cir.get_member [[VARLIST]][2] {name = "vr_top"} : !cir.ptr<!rec___va_list> -> !cir.ptr<!cir.ptr<!void>>
-// AFTER-NEXT: [[VR_TOP:%.*]] = cir.load [[VR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// AFTER-NEXT: [[VR_TOP:%.*]] = cir.load{{.*}} [[VR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[TMP2:%.*]] = cir.cast(bitcast, [[VR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<i8>, [[VR_OFFS]] : !s32i), !cir.ptr<i8>
 // AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast(bitcast, [[TMP3]] : !cir.ptr<i8>), !cir.ptr<!void>
@@ -57,7 +57,7 @@ double f1(int n, ...) {
 
 // AFTER: [[BB_ON_STACK]]:
 // AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!rec___va_list> -> !cir.ptr<!cir.ptr<!void>>
-// AFTER-NEXT: [[STACK_V:%.*]] = cir.load [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// AFTER-NEXT: [[STACK_V:%.*]] = cir.load{{.*}} [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[EIGHT_IN_PTR_ARITH:%.*]]  = cir.const #cir.int<8> : !u64i
 // AFTER-NEXT: [[TMP4:%.*]] = cir.cast(bitcast, [[STACK_V]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP5:%.*]] = cir.ptr_stride([[TMP4]] : !cir.ptr<i8>, [[EIGHT_IN_PTR_ARITH]] : !u64i), !cir.ptr<i8>
@@ -67,12 +67,12 @@ double f1(int n, ...) {
 
 // AFTER-NEXT: [[BB_END]]([[BLK_ARG:%.*]]: !cir.ptr<!void>):  // 2 preds: [[BB_IN_REG]], [[BB_ON_STACK]]
 // AFTER-NEXT:  [[TMP0:%.*]] = cir.cast(bitcast, [[BLK_ARG]] : !cir.ptr<!void>), !cir.ptr<!cir.double>
-// AFTER-NEXT:  [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.double>, !cir.double
+// AFTER-NEXT:  [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.double>, !cir.double
 // AFTER:   cir.store{{.*}} [[TMP1]], [[RESP]] : !cir.double, !cir.ptr<!cir.double>
 // AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!rec___va_list>
-// AFTER:   [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!cir.double>, !cir.double
+// AFTER:   [[RES:%.*]] = cir.load{{.*}} [[RESP]] : !cir.ptr<!cir.double>, !cir.double
 // AFTER:   cir.store{{.*}} [[RES]], [[RETP]] : !cir.double, !cir.ptr<!cir.double>
-// AFTER:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!cir.double>, !cir.double
+// AFTER:  [[RETV:%.*]] = cir.load{{.*}} [[RETP]] : !cir.ptr<!cir.double>, !cir.double
 // AFTER:   cir.return [[RETV]] : !cir.double
 
 // beginning block llvm code
diff --git a/clang/test/CIR/CodeGen/var-arg.c b/clang/test/CIR/CodeGen/var-arg.c
index 49aff54443d7..163e2ed111ac 100644
--- a/clang/test/CIR/CodeGen/var-arg.c
+++ b/clang/test/CIR/CodeGen/var-arg.c
@@ -21,9 +21,9 @@ int f1(int n, ...) {
 // BEFORE:  [[TMP0:%.*]] = cir.va.arg [[VARLIST]] : (!cir.ptr<!rec___va_list>) -> !s32i
 // BEFORE:  cir.store{{.*}} [[TMP0]], [[RESP]] : !s32i, !cir.ptr<!s32i>
 // BEFORE:  cir.va.end [[VARLIST]] : !cir.ptr<!rec___va_list>
-// BEFORE:  [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!s32i>, !s32i
+// BEFORE:  [[RES:%.*]] = cir.load{{.*}} [[RESP]] : !cir.ptr<!s32i>, !s32i
 // BEFORE:   cir.store{{.*}} [[RES]], [[RETP]] : !s32i, !cir.ptr<!s32i>
-// BEFORE:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!s32i>, !s32i
+// BEFORE:  [[RETV:%.*]] = cir.load{{.*}} [[RETP]] : !cir.ptr<!s32i>, !s32i
 // BEFORE:   cir.return [[RETV]] : !s32i
 
 // AFTER: !rec___va_list = !cir.record<struct "__va_list" {!cir.ptr<!void>, !cir.ptr<!void>, !cir.ptr<!void>, !s32i, !s32i}
@@ -32,7 +32,7 @@ int f1(int n, ...) {
 // AFTER:  [[RESP:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["res", init]
 // AFTER:  cir.va.start [[VARLIST:%.*]] : !cir.ptr<!rec___va_list>
 // AFTER:  [[GR_OFFS_P:%.*]] = cir.get_member [[VARLIST]][3] {name = "gr_offs"} : !cir.ptr<!rec___va_list> -> !cir.ptr<!s32i>
-// AFTER:  [[GR_OFFS:%.*]] = cir.load [[GR_OFFS_P]] : !cir.ptr<!s32i>, !s32i
+// AFTER:  [[GR_OFFS:%.*]] = cir.load{{.*}} [[GR_OFFS_P]] : !cir.ptr<!s32i>, !s32i
 // AFTER:  [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
 // AFTER:  [[CMP0:%.*]] = cir.cmp(ge, [[GR_OFFS]], [[ZERO]]) : !s32i, !cir.bool
 // AFTER-NEXT:  cir.brcond [[CMP0]] [[BB_ON_STACK:\^bb.*]], [[BB_MAY_REG:\^bb.*]]
@@ -48,7 +48,7 @@ int f1(int n, ...) {
 // arg is passed in register.
 // AFTER: [[BB_IN_REG]]:
 // AFTER-NEXT: [[GR_TOP_P:%.*]] = cir.get_member [[VARLIST]][1] {name = "gr_top"} : !cir.ptr<!rec___va_list> -> !cir.ptr<!cir.ptr<!void>>
-// AFTER-NEXT: [[GR_TOP:%.*]] = cir.load [[GR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// AFTER-NEXT: [[GR_TOP:%.*]] = cir.load{{.*}} [[GR_TOP_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[TMP2:%.*]] = cir.cast(bitcast, [[GR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr<i8>, [[GR_OFFS]] : !s32i), !cir.ptr<i8>
 // AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast(bitcast, [[TMP3]] : !cir.ptr<i8>), !cir.ptr<!void>
@@ -57,7 +57,7 @@ int f1(int n, ...) {
 // arg is passed in stack.
 // AFTER: [[BB_ON_STACK]]:
 // AFTER-NEXT: [[STACK_P:%.*]] = cir.get_member [[VARLIST]][0] {name = "stack"} : !cir.ptr<!rec___va_list> -> !cir.ptr<!cir.ptr<!void>>
-// AFTER-NEXT: [[STACK_V:%.*]] = cir.load [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// AFTER-NEXT: [[STACK_V:%.*]] = cir.load{{.*}} [[STACK_P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: [[EIGHT_IN_PTR_ARITH:%.*]]  = cir.const #cir.int<8> : !u64i
 // AFTER-NEXT: [[TMP4:%.*]] = cir.cast(bitcast, [[STACK_V]] : !cir.ptr<!void>), !cir.ptr<i8>
 // AFTER-NEXT: [[TMP5:%.*]] = cir.ptr_stride([[TMP4]] : !cir.ptr<i8>, [[EIGHT_IN_PTR_ARITH]] : !u64i), !cir.ptr<i8>
@@ -71,12 +71,12 @@ int f1(int n, ...) {
 // Or from ON_STACK block which means arg is passed in from caller's stack area.
 // AFTER-NEXT: [[BB_END]]([[BLK_ARG:%.*]]: !cir.ptr<!void>):  // 2 preds: [[BB_IN_REG]], [[BB_ON_STACK]]
 // AFTER-NEXT:  [[TMP0:%.*]] = cir.cast(bitcast, [[BLK_ARG]] : !cir.ptr<!void>), !cir.ptr<!s32i>
-// AFTER-NEXT:  [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!s32i>, !s32i
+// AFTER-NEXT:  [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!s32i>, !s32i
 // AFTER:   cir.store{{.*}} [[TMP1]], [[RESP]] : !s32i, !cir.ptr<!s32i>
 // AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!rec___va_list>
-// AFTER:   [[RES:%.*]] = cir.load [[RESP]] : !cir.ptr<!s32i>, !s32i
+// AFTER:   [[RES:%.*]] = cir.load{{.*}} [[RESP]] : !cir.ptr<!s32i>, !s32i
 // AFTER:   cir.store{{.*}} [[RES]], [[RETP]] : !s32i, !cir.ptr<!s32i>
-// AFTER:  [[RETV:%.*]] = cir.load [[RETP]] : !cir.ptr<!s32i>, !s32i
+// AFTER:  [[RETV:%.*]] = cir.load{{.*}} [[RETP]] : !cir.ptr<!s32i>, !s32i
 // AFTER:   cir.return [[RETV]] : !s32i
 
 // LLVM: %struct.__va_list = type { ptr, ptr, ptr, i32, i32 }
diff --git a/clang/test/CIR/CodeGen/vector.cpp b/clang/test/CIR/CodeGen/vector.cpp
index f097aa6149cd..c524b8339771 100644
--- a/clang/test/CIR/CodeGen/vector.cpp
+++ b/clang/test/CIR/CodeGen/vector.cpp
@@ -17,11 +17,11 @@ namespace std {
 // CHECK:   %2 = cir.alloca !u64i, !cir.ptr<!u64i>, ["__cs", init] {alignment = 8 : i64}
 // CHECK:   cir.store{{.*}} %arg0, %0 : !cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>, !cir.ptr<!cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>>
 // CHECK:   cir.store{{.*}} %arg1, %1 : !u64i, !cir.ptr<!u64i>
-// CHECK:   %3 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>>, !cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>
+// CHECK:   %3 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>>, !cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>
 // CHECK:   %4 = cir.call @_ZNKSt6vectorIyE4sizeEv(%3) : (!cir.ptr<!rec_std3A3Avector3Cunsigned_long_long3E>) -> !u64i
 // CHECK:   cir.store{{.*}} %4, %2 : !u64i, !cir.ptr<!u64i>
 // CHECK:   cir.scope {
-// CHECK:     %5 = cir.load %2 : !cir.ptr<!u64i>, !u64i
+// CHECK:     %5 = cir.load{{.*}} %2 : !cir.ptr<!u64i>, !u64i
 // CHECK:     %6 = cir.cast(int_to_bool, %5 : !u64i), !cir.bool
 // CHECK:     cir.if %6 {
 // CHECK:     }
diff --git a/clang/test/CIR/CodeGen/vectype-ext.cpp b/clang/test/CIR/CodeGen/vectype-ext.cpp
index a54787458da5..883562fbcc15 100644
--- a/clang/test/CIR/CodeGen/vectype-ext.cpp
+++ b/clang/test/CIR/CodeGen/vectype-ext.cpp
@@ -98,7 +98,7 @@ void vector_int_test(int x) {
 
   // Insert element
   a[x] = x;
-  // CIR: %[[#LOADEDVI:]] = cir.load %[[#STORAGEVI:]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR: %[[#LOADEDVI:]] = cir.load{{.*}} %[[#STORAGEVI:]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR: %[[#UPDATEDVI:]] = cir.vec.insert %{{[0-9]+}}, %[[#LOADEDVI]][%{{[0-9]+}} : !s32i] : !cir.vector<!s32i x 4>
   // CIR: cir.store{{.*}} %[[#UPDATEDVI]], %[[#STORAGEVI]] : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
   // LLVM:      %[[#X1:]] = load i32, ptr %{{[0-9]+}}, align 4
@@ -270,7 +270,7 @@ void vector_double_test(int x, double y) {
 
   // Insert element
   a[x] = y;
-  // CIR: %[[#LOADEDVF:]] = cir.load %[[#STORAGEVF:]] : !cir.ptr<!cir.vector<!cir.double x 2>>, !cir.vector<!cir.double x 2>
+  // CIR: %[[#LOADEDVF:]] = cir.load{{.*}} %[[#STORAGEVF:]] : !cir.ptr<!cir.vector<!cir.double x 2>>, !cir.vector<!cir.double x 2>
   // CIR: %[[#UPDATEDVF:]] = cir.vec.insert %{{[0-9]+}}, %[[#LOADEDVF]][%{{[0-9]+}} : !s32i] : !cir.vector<!cir.double x 2>
   // CIR: cir.store{{.*}} %[[#UPDATEDVF]], %[[#STORAGEVF]] : !cir.vector<!cir.double x 2>, !cir.ptr<!cir.vector<!cir.double x 2>>
 
@@ -345,7 +345,7 @@ void test_load() {
   vi2 b;
 
   b = a.wz;
-  // CIR:      %[[#LOAD1:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR:      %[[#LOAD1:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#SHUFFLE1:]] = cir.vec.shuffle(%[[#LOAD1]], %[[#LOAD1]] : !cir.vector<!s32i x 4>) [#cir.int<3> : !s32i, #cir.int<2> : !s32i] : !cir.vector<!s32i x 2>
   // CIR-NEXT: cir.store{{.*}} %[[#SHUFFLE1]], %{{[0-9]+}} : !cir.vector<!s32i x 2>, !cir.ptr<!cir.vector<!s32i x 2>>
 
@@ -354,7 +354,7 @@ void test_load() {
   // LLVM-NEXT: store <2 x i32> %[[#SHUFFLE1]], ptr %{{[0-9]+}}, align 8
 
   int one_elem_load = a.s2;
-  // CIR-NEXT: %[[#LOAD8:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#LOAD8:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#EXTRACT_INDEX:]] = cir.const #cir.int<2> : !s64i
   // CIR-NEXT: %[[#EXTRACT1:]] = cir.vec.extract %[[#LOAD8]][%[[#EXTRACT_INDEX]] : !s64i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#EXTRACT1]], %{{[0-9]+}} : !s32i, !cir.ptr<!s32i>
@@ -381,8 +381,8 @@ void test_store() {
   // LLVM-NEXT: %[[#PVECC:]] = alloca <3 x i32>
 
   a.xy = b;
-  // CIR:      %[[#LOAD4RHS:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 2>>, !cir.vector<!s32i x 2>
-  // CIR-NEXT: %[[#LOAD5LHS:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR:      %[[#LOAD4RHS:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 2>>, !cir.vector<!s32i x 2>
+  // CIR-NEXT: %[[#LOAD5LHS:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#SHUFFLE5:]] = cir.vec.shuffle(%[[#LOAD4RHS]], %[[#LOAD4RHS]] : !cir.vector<!s32i x 2>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#SHUFFLE6:]] = cir.vec.shuffle(%[[#LOAD5LHS]], %[[#SHUFFLE5]] : !cir.vector<!s32i x 4>) [#cir.int<4> : !s32i, #cir.int<5> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#SHUFFLE6]], %{{[0-9]+}} : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
@@ -396,7 +396,7 @@ void test_store() {
   // load single element
   a.s0 = 1;
   // CIR-NEXT: cir.const #cir.int<1>
-  // CIR-NEXT: %[[#LOAD7:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#LOAD7:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#INSERT_INDEX:]] = cir.const #cir.int<0> : !s64i
   // CIR-NEXT: %[[#INSERT1:]] = cir.vec.insert %{{[0-9]+}}, %[[#LOAD7]][%[[#INSERT_INDEX]] : !s64i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#INSERT1]], %{{[0-9]+}} : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
@@ -407,8 +407,8 @@ void test_store() {
 
   // extend length from 2 to 4, then merge two vectors
   a.lo = b;
-  // CIR:      %[[#VECB:]] = cir.load %[[#PVECB]] : !cir.ptr<!cir.vector<!s32i x 2>>, !cir.vector<!s32i x 2>
-  // CIR-NEXT: %[[#VECA:]] = cir.load %[[#PVECA]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR:      %[[#VECB:]] = cir.load{{.*}} %[[#PVECB]] : !cir.ptr<!cir.vector<!s32i x 2>>, !cir.vector<!s32i x 2>
+  // CIR-NEXT: %[[#VECA:]] = cir.load{{.*}} %[[#PVECA]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#EXTVECB:]] = cir.vec.shuffle(%[[#VECB]], %[[#VECB]] : !cir.vector<!s32i x 2>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#RESULT:]] = cir.vec.shuffle(%[[#VECA]], %[[#EXTVECB]] : !cir.vector<!s32i x 4>) [#cir.int<4> : !s32i, #cir.int<5> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#RESULT]], %[[#PVECA]] : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
@@ -425,7 +425,7 @@ void test_store() {
   // the value in the w component undefined.
   b = c.hi;
 
-  // CIR-NEXT: %[[#VECC:]] = cir.load %[[#PVECC]] : !cir.ptr<!cir.vector<!s32i x 3>>, !cir.vector<!s32i x 3>
+  // CIR-NEXT: %[[#VECC:]] = cir.load{{.*}} %[[#PVECC]] : !cir.ptr<!cir.vector<!s32i x 3>>, !cir.vector<!s32i x 3>
   // CIR-NEXT: %[[#HIPART:]] = cir.vec.shuffle(%[[#VECC]], %[[#VECC]] : !cir.vector<!s32i x 3>) [#cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s32i x 2>
   // CIR-NEXT: cir.store{{.*}} %[[#HIPART]], %[[#PVECB]] : !cir.vector<!s32i x 2>, !cir.ptr<!cir.vector<!s32i x 2>>
 
@@ -436,8 +436,8 @@ void test_store() {
   // c.hi is c[2, 3], in which 3 should be ignored in CIRGen for store
   c.hi = b;
 
-  // CIR-NEXT: %[[#VECB:]] = cir.load %[[#PVECB]] : !cir.ptr<!cir.vector<!s32i x 2>>, !cir.vector<!s32i x 2>
-  // CIR-NEXT: %[[#VECC:]] = cir.load %[[#PVECC]] : !cir.ptr<!cir.vector<!s32i x 3>>, !cir.vector<!s32i x 3>
+  // CIR-NEXT: %[[#VECB:]] = cir.load{{.*}} %[[#PVECB]] : !cir.ptr<!cir.vector<!s32i x 2>>, !cir.vector<!s32i x 2>
+  // CIR-NEXT: %[[#VECC:]] = cir.load{{.*}} %[[#PVECC]] : !cir.ptr<!cir.vector<!s32i x 3>>, !cir.vector<!s32i x 3>
   // CIR-NEXT: %[[#EXTVECB:]] = cir.vec.shuffle(%[[#VECB]], %[[#VECB]] : !cir.vector<!s32i x 2>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<-1> : !s32i] : !cir.vector<!s32i x 3>
   // CIR-NEXT: %[[#RESULT:]] = cir.vec.shuffle(%[[#VECC]], %[[#EXTVECB]] : !cir.vector<!s32i x 3>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s32i x 3>
   // CIR-NEXT: cir.store{{.*}} %[[#RESULT]], %[[#PVECC]] : !cir.vector<!s32i x 3>, !cir.ptr<!cir.vector<!s32i x 3>>
@@ -471,8 +471,8 @@ void test_build_lvalue() {
 
   pv->x = 99;
   // CIR-NEXT: %[[#VAL:]] = cir.const #cir.int<99> : !s32i
-  // CIR-NEXT: %[[#PV:]] = cir.load %[[#ALLOCAPV]] : !cir.ptr<!cir.ptr<!cir.vector<!s32i x 4>>>, !cir.ptr<!cir.vector<!s32i x 4>>
-  // CIR-NEXT: %[[#V:]] = cir.load %[[#PV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#PV:]] = cir.load{{.*}} %[[#ALLOCAPV]] : !cir.ptr<!cir.ptr<!cir.vector<!s32i x 4>>>, !cir.ptr<!cir.vector<!s32i x 4>>
+  // CIR-NEXT: %[[#V:]] = cir.load{{.*}} %[[#PV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#IDX:]] = cir.const #cir.int<0> : !s64i
   // CIR-NEXT: %[[#RESULT:]] = cir.vec.insert %[[#VAL]], %[[#V]][%[[#IDX]] : !s64i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#RESULT]], %[[#PV]] : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
@@ -484,11 +484,11 @@ void test_build_lvalue() {
 
   int s = (v+v).x;
 
-  // CIR-NEXT: %[[#LOAD1:]] = cir.load %[[#ALLOCAV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
-  // CIR-NEXT: %[[#LOAD2:]] = cir.load %[[#ALLOCAV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#LOAD1:]] = cir.load{{.*}} %[[#ALLOCAV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#LOAD2:]] = cir.load{{.*}} %[[#ALLOCAV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#SUM:]] = cir.binop(add, %[[#LOAD1]], %[[#LOAD2]]) : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#SUM]], %[[#ALLOCATMP]] : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
-  // CIR-NEXT: %[[#TMP:]] = cir.load %[[#ALLOCATMP]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#TMP:]] = cir.load{{.*}} %[[#ALLOCATMP]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#IDX:]] = cir.const #cir.int<0> : !s64i
   // CIR-NEXT: %[[#RESULT:]] = cir.vec.extract %[[#TMP]][%[[#IDX]] : !s64i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#RESULT]], %[[#ALLOCAS]] : !s32i, !cir.ptr<!s32i>
@@ -502,7 +502,7 @@ void test_build_lvalue() {
   // LLVM-NEXT: store i32 %[[#RESULT]], ptr %[[#ALLOCAS]], align 4
 
   int r = v.xy.x;
-  // CIR-NEXT: %[[#V:]] = cir.load %[[#ALLOCAV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#V:]] = cir.load{{.*}} %[[#ALLOCAV]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#IDX:]] = cir.const #cir.int<0> : !s64i
   // CIR-NEXT: %[[#RESULT:]] = cir.vec.extract %[[#V]][%[[#IDX]] : !s64i] : !cir.vector<!s32i x 4>
   // CIR-NEXT: cir.store{{.*}} %[[#RESULT]], %[[#ALLOCAR]] : !s32i, !cir.ptr<!s32i>
@@ -526,7 +526,7 @@ void test_vec3() {
 
   v + 1;
   // CIR-NEXT: %[[#PV4:]] = cir.cast(bitcast, %[[#PV]] : !cir.ptr<!cir.vector<!s32i x 3>>), !cir.ptr<!cir.vector<!s32i x 4>>
-  // CIR-NEXT: %[[#V4:]] = cir.load %[[#PV4]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CIR-NEXT: %[[#V4:]] = cir.load{{.*}} %[[#PV4]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#V3:]] = cir.vec.shuffle(%[[#V4]], %[[#V4]] : !cir.vector<!s32i x 4>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i] : !cir.vector<!s32i x 3>
   // CIR:      %[[#RES:]] = cir.binop(add, %[[#V3]], %{{[0-9]+}}) : !cir.vector<!s32i x 3>
 
diff --git a/clang/test/CIR/CodeGen/vectype.cpp b/clang/test/CIR/CodeGen/vectype.cpp
index 8016bdef9963..ac3e0681c60e 100644
--- a/clang/test/CIR/CodeGen/vectype.cpp
+++ b/clang/test/CIR/CodeGen/vectype.cpp
@@ -51,19 +51,19 @@ void vector_int_test(int x, unsigned short usx) {
 
   // Insert element
   a[x] = x;
-  // CHECK: %[[#LOADEDVI:]] = cir.load %[[#STORAGEVI:]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CHECK: %[[#LOADEDVI:]] = cir.load{{.*}} %[[#STORAGEVI:]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CHECK: %[[#UPDATEDVI:]] = cir.vec.insert %{{[0-9]+}}, %[[#LOADEDVI]][%{{[0-9]+}} : !s32i] : !cir.vector<!s32i x 4>
   // CHECK: cir.store{{.*}} %[[#UPDATEDVI]], %[[#STORAGEVI]] : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
 
   // Compound assignment
   a[x] += a[0];
-  // CHECK: %[[#LOADCA1:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CHECK: %[[#LOADCA1:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CHECK: %[[#RHSCA:]] = cir.vec.extract %[[#LOADCA1]][%{{[0-9]+}} : !s32i] : !cir.vector<!s32i x 4>
-  // CHECK: %[[#LOADCAIDX2:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s32i>, !s32i
-  // CHECK: %[[#LOADCAVEC3:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CHECK: %[[#LOADCAIDX2:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s32i>, !s32i
+  // CHECK: %[[#LOADCAVEC3:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CHECK: %[[#LHSCA:]] = cir.vec.extract %[[#LOADCAVEC3]][%[[#LOADCAIDX2]] : !s32i] : !cir.vector<!s32i x 4>
   // CHECK: %[[#SUMCA:]] = cir.binop(add, %[[#LHSCA]], %[[#RHSCA]]) nsw : !s32i
-  // CHECK: %[[#LOADCAVEC4:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
+  // CHECK: %[[#LOADCAVEC4:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
   // CHECK: %[[#RESULTCAVEC:]] = cir.vec.insert %[[#SUMCA]], %[[#LOADCAVEC4]][%[[#LOADCAIDX2]] : !s32i] : !cir.vector<!s32i x 4>
   // CHECK: cir.store{{.*}} %[[#RESULTCAVEC]], %{{[0-9]+}} : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
 
@@ -160,7 +160,7 @@ void vector_double_test(int x, double y) {
 
   // Insert element
   a[x] = y;
-  // CHECK: %[[#LOADEDVF:]] = cir.load %[[#STORAGEVF:]] : !cir.ptr<!cir.vector<!cir.double x 2>>, !cir.vector<!cir.double x 2>
+  // CHECK: %[[#LOADEDVF:]] = cir.load{{.*}} %[[#STORAGEVF:]] : !cir.ptr<!cir.vector<!cir.double x 2>>, !cir.vector<!cir.double x 2>
   // CHECK: %[[#UPDATEDVF:]] = cir.vec.insert %{{[0-9]+}}, %[[#LOADEDVF]][%{{[0-9]+}} : !s32i] : !cir.vector<!cir.double x 2>
   // CHECK: cir.store{{.*}} %[[#UPDATEDVF]], %[[#STORAGEVF]] : !cir.vector<!cir.double x 2>, !cir.ptr<!cir.vector<!cir.double x 2>>
 
diff --git a/clang/test/CIR/CodeGen/virtual-base-cast.cpp b/clang/test/CIR/CodeGen/virtual-base-cast.cpp
index 9d7ed39bc91f..56c0ffc34d4d 100644
--- a/clang/test/CIR/CodeGen/virtual-base-cast.cpp
+++ b/clang/test/CIR/CodeGen/virtual-base-cast.cpp
@@ -19,7 +19,7 @@ A* a() { return x; }
 // CIR:  %[[OFFSET_OFFSET:.*]] = cir.const #cir.int<-32> : !s64i
 // CIR:  %[[OFFSET_PTR:.*]] = cir.ptr_stride(%4 : !cir.ptr<!u8i>, %[[OFFSET_OFFSET]] : !s64i), !cir.ptr<!u8i>
 // CIR:  %[[OFFSET_PTR_CAST:.*]] = cir.cast(bitcast, %[[OFFSET_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!s64i>
-// CIR:  %[[OFFSET:.*]] = cir.load %[[OFFSET_PTR_CAST]] : !cir.ptr<!s64i>, !s64i
+// CIR:  %[[OFFSET:.*]] = cir.load{{.*}} %[[OFFSET_PTR_CAST]] : !cir.ptr<!s64i>, !s64i
 // CIR:  %[[VBASE_ADDR:.*]] = cir.ptr_stride({{.*}} : !cir.ptr<!u8i>, %[[OFFSET]] : !s64i), !cir.ptr<!u8i>
 // CIR:  cir.cast(bitcast, %[[VBASE_ADDR]] : !cir.ptr<!u8i>), !cir.ptr<!rec_D>
 
@@ -41,7 +41,7 @@ F* y;
 
 BB* d() { return y; }
 // CIR-LABEL: @_Z1dv
-// CIR: %[[OFFSET:.*]] = cir.load {{.*}} : !cir.ptr<!s64i>, !s64i
+// CIR: %[[OFFSET:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s64i>, !s64i
 // CIR: %[[ADJUST:.*]] = cir.const #cir.int<16> : !s64i
 // CIR: cir.binop(add, %[[OFFSET]], %[[ADJUST]]) : !s64i
 
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index 3eb826f271d8..70cdf45def15 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -4,12 +4,12 @@
 // CHECK:    [[TMP0:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init] {alignment = 4 : i64}
 // CHECK:    [[TMP1:%.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"] {alignment = 8 : i64}
 // CHECK:    cir.store{{.*}} %arg0, [[TMP0]] : !s32i, !cir.ptr<!s32i>
-// CHECK:    [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr<!s32i>, !s32i
+// CHECK:    [[TMP2:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!s32i>, !s32i
 // CHECK:    [[TMP3:%.*]] = cir.cast(integral, [[TMP2]] : !s32i), !u64i
 // CHECK:    [[TMP4:%.*]] = cir.stack_save : !cir.ptr<!u8i>
 // CHECK:    cir.store{{.*}} [[TMP4]], [[TMP1]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
 // CHECK:    [[TMP5:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, [[TMP3]] : !u64i, ["vla"] {alignment = 16 : i64}
-// CHECK:    [[TMP6:%.*]] = cir.load [[TMP1]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+// CHECK:    [[TMP6:%.*]] = cir.load{{.*}} [[TMP1]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
 // CHECK:    cir.stack_restore [[TMP6]] : !cir.ptr<!u8i>
 void f0(int len) {
     int a[len];
diff --git a/clang/test/CIR/CodeGen/volatile.cpp b/clang/test/CIR/CodeGen/volatile.cpp
index f2736cd0715b..43bb668c88f0 100644
--- a/clang/test/CIR/CodeGen/volatile.cpp
+++ b/clang/test/CIR/CodeGen/volatile.cpp
@@ -27,7 +27,7 @@ int test_load_field1(volatile Foo *ptr) {
 
 // CHECK: cir.func @_Z16test_load_field1PV3Foo
 // CHECK:   %[[MemberAddr:.*]] = cir.get_member
-// CHECK:   %{{.+}} = cir.load volatile %[[MemberAddr]]
+// CHECK:   %{{.+}} = cir.load volatile{{.*}} %[[MemberAddr]]
 
 int test_load_field2(Foo *ptr) {
   return ptr->y;
@@ -35,7 +35,7 @@ int test_load_field2(Foo *ptr) {
 
 // CHECK: cir.func @_Z16test_load_field2P3Foo
 // CHECK:   %[[MemberAddr:.+]] = cir.get_member
-// CHECK:   %{{.+}} = cir.load volatile %[[MemberAddr]]
+// CHECK:   %{{.+}} = cir.load volatile{{.*}} %[[MemberAddr]]
 
 int test_load_field3(Foo *ptr) {
   return ptr->z;
diff --git a/clang/test/CIR/CodeGen/vtt.cpp b/clang/test/CIR/CodeGen/vtt.cpp
index 8c159c4c4d3d..5c22777d300f 100644
--- a/clang/test/CIR/CodeGen/vtt.cpp
+++ b/clang/test/CIR/CodeGen/vtt.cpp
@@ -58,11 +58,11 @@ int f() {
 // CIR:   %{{[0-9]+}} = cir.vtt.address_point %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>, offset = 1 -> !cir.ptr<!cir.ptr<!void>>
 // CIR:   %{{[0-9]+}} = cir.load align(8) %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!rec_B>), !cir.ptr<!cir.ptr<!u8i>>
-// CIR:   %{{[0-9]+}} = cir.load %{{[0-9]+}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+// CIR:   %{{[0-9]+}} = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.const #cir.int<-24> : !s64i
 // CIR:   %{{[0-9]+}} = cir.ptr_stride(%{{[0-9]+}} : !cir.ptr<!u8i>, %{{[0-9]+}} : !s64i), !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!u8i>), !cir.ptr<!s64i>
-// CIR:   %{{[0-9]+}} = cir.load %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
+// CIR:   %{{[0-9]+}} = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
 // CIR:   %{{[0-9]+}} = cir.ptr_stride(%{{[0-9]+}} : !cir.ptr<!u8i>, %{{[0-9]+}} : !s64i), !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!rec_B>), !cir.ptr<!cir.ptr<!void>>
 // CIR:   cir.store{{.*}} %{{[0-9]+}}, %{{[0-9]+}} : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
@@ -89,11 +89,11 @@ int f() {
 // CIR:   %{{[0-9]+}} = cir.vtt.address_point %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>, offset = 1 -> !cir.ptr<!cir.ptr<!void>>
 // CIR:   %{{[0-9]+}} = cir.load align(8) %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!rec_C>), !cir.ptr<!cir.ptr<!u8i>>
-// CIR:   %{{[0-9]+}} = cir.load %{{[0-9]+}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
+// CIR:   %{{[0-9]+}} = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.const #cir.int<-24> : !s64i
 // CIR:   %{{[0-9]+}} = cir.ptr_stride(%{{[0-9]+}} : !cir.ptr<!u8i>, %{{[0-9]+}} : !s64i), !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!u8i>), !cir.ptr<!s64i>
-// CIR:   %{{[0-9]+}} = cir.load %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
+// CIR:   %{{[0-9]+}} = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
 // CIR:   %{{[0-9]+}} = cir.ptr_stride(%{{[0-9]+}} : !cir.ptr<!u8i>, %{{[0-9]+}} : !s64i), !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!rec_C>), !cir.ptr<!cir.ptr<!void>>
 // CIR:   cir.store{{.*}} %{{[0-9]+}}, %{{[0-9]+}} : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
@@ -103,7 +103,7 @@ int f() {
 // CIR: cir.func linkonce_odr @_ZN1DC1Ev(%arg0: !cir.ptr<!rec_D>
 // CIR:   %{{[0-9]+}} = cir.alloca !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>, ["this", init] {alignment = 8 : i64}
 // CIR:   cir.store{{.*}} %arg0, %{{[0-9]+}} : !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>
-// CIR:   %[[D_PTR:.*]] = cir.load %0 : !cir.ptr<!cir.ptr<!rec_D>>, !cir.ptr<!rec_D>
+// CIR:   %[[D_PTR:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!rec_D>>, !cir.ptr<!rec_D>
 // CIR:   %[[A_PTR:.*]] = cir.base_class_addr(%[[D_PTR]] : !cir.ptr<!rec_D> nonnull) [40] -> !cir.ptr<!rec_A>
 // CIR:   cir.call @_ZN1AC2Ev(%[[A_PTR]]) : (!cir.ptr<!rec_A>) -> ()
 
@@ -169,7 +169,7 @@ namespace other {
 // CIR-SAME:                               %[[VAL_0:.*]]: !cir.ptr<!rec_other3A3AB>
 // CIR:           %[[VAL_1:.*]] = cir.alloca !cir.ptr<!rec_other3A3AB>, !cir.ptr<!cir.ptr<!rec_other3A3AB>>, ["this", init] {alignment = 8 : i64}
 // CIR:           cir.store{{.*}} %[[VAL_0]], %[[VAL_1]] : !cir.ptr<!rec_other3A3AB>, !cir.ptr<!cir.ptr<!rec_other3A3AB>>
-// CIR:           %[[VAL_2:.*]] = cir.load %[[VAL_1]] : !cir.ptr<!cir.ptr<!rec_other3A3AB>>, !cir.ptr<!rec_other3A3AB>
+// CIR:           %[[VAL_2:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.ptr<!rec_other3A3AB>>, !cir.ptr<!rec_other3A3AB>
 // CIR:           %[[VAL_3:.*]] = cir.vtt.address_point @_ZTTN5other1BE, offset = 0 -> !cir.ptr<!cir.ptr<!void>>
 // CIR:           cir.call @_ZN5other1BD2Ev(%[[VAL_2]], %[[VAL_3]]) : (!cir.ptr<!rec_other3A3AB>, !cir.ptr<!cir.ptr<!void>>) -> ()
 // CIR:           %[[VAL_4:.*]] = cir.base_class_addr(%[[VAL_2]] : !cir.ptr<!rec_other3A3AB> nonnull) [0] -> !cir.ptr<!rec_other3A3AA>
diff --git a/clang/test/CIR/Transforms/lib-opt-find.cpp b/clang/test/CIR/Transforms/lib-opt-find.cpp
index 0f26ce4175a4..104f2a73f45d 100644
--- a/clang/test/CIR/Transforms/lib-opt-find.cpp
+++ b/clang/test/CIR/Transforms/lib-opt-find.cpp
@@ -15,7 +15,7 @@ int test1(unsigned char n = 3)
     // CHECK: %[[first:.*]] = cir.call @_ZNSt5arrayIhLj9EE5beginEv
     // CHECK: %[[last:.*]] = cir.call @_ZNSt5arrayIhLj9EE3endEv
     // CHECK: %[[cast_to_void:.*]] = cir.cast(bitcast, %[[first]] : !cir.ptr<!u8i>), !cir.ptr<!void>
-    // CHECK: %[[load_pattern:.*]] = cir.load %[[pattern_addr]] : !cir.ptr<!u8i>, !u8i
+    // CHECK: %[[load_pattern:.*]] = cir.load{{.*}} %[[pattern_addr]] : !cir.ptr<!u8i>, !u8i
     // CHECK: %[[pattern:.*]] = cir.cast(integral, %[[load_pattern:.*]] : !u8i), !s32i
 
     // CHECK-NOT: {{.*}} cir.call @_ZSt4findIPhhET_S1_S1_RKT0_(
@@ -45,10 +45,10 @@ unsigned char* test2(unsigned char* first, unsigned char* last, unsigned char v)
     // CHECK: %[[first_storage:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["first", init]
     // CHECK: %[[last_storage:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["last", init]
     // CHECK: %[[pattern_storage:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["v", init]
-    // CHECK: %[[first:.*]] = cir.load %[[first_storage]]
-    // CHECK: %[[last:.*]] = cir.load %[[last_storage]]
+    // CHECK: %[[first:.*]] = cir.load{{.*}} %[[first_storage]]
+    // CHECK: %[[last:.*]] = cir.load{{.*}} %[[last_storage]]
     // CHECK: %[[cast_to_void:.*]] = cir.cast(bitcast, %[[first]] : !cir.ptr<!u8i>), !cir.ptr<!void>
-    // CHECK: %[[load_pattern:.*]] = cir.load %[[pattern_storage]] : !cir.ptr<!u8i>, !u8i
+    // CHECK: %[[load_pattern:.*]] = cir.load{{.*}} %[[pattern_storage]] : !cir.ptr<!u8i>, !u8i
     // CHECK: %[[pattern:.*]] = cir.cast(integral, %[[load_pattern:.*]] : !u8i), !s32i
 
     // CHECK-NOT: {{.*}} cir.call @_ZSt4findIPhhET_S1_S1_RKT0_(
diff --git a/clang/test/CIR/Transforms/mem2reg.c b/clang/test/CIR/Transforms/mem2reg.c
index 93bff50c78ad..321f079f715f 100644
--- a/clang/test/CIR/Transforms/mem2reg.c
+++ b/clang/test/CIR/Transforms/mem2reg.c
@@ -13,9 +13,9 @@ int return_42() {
 // BEFORE:   %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
 // BEFORE:   %2 = cir.const #cir.int<42> : !s32i
 // BEFORE:   cir.store{{.*}} %2, %1 : !s32i, !cir.ptr<!s32i>
-// BEFORE:   %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// BEFORE:   %3 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // BEFORE:   cir.store{{.*}} %3, %0 : !s32i, !cir.ptr<!s32i>
-// BEFORE:   %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// BEFORE:   %4 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // BEFORE:   cir.return %4 : !s32i
 
 // MEM2REG:  cir.func {{.*@return_42()}}
@@ -39,8 +39,8 @@ void alloca_in_loop(int* ar, int n) {
 // BEFORE:      %3 = cir.const #cir.int<0> : !s32i
 // BEFORE:      cir.store{{.*}} %3, %2 : !s32i, !cir.ptr<!s32i>
 // BEFORE:      cir.for : cond {
-// BEFORE:        %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
-// BEFORE:        %5 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %4 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %5 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // BEFORE:        %6 = cir.cmp(lt, %4, %5) : !s32i, !cir.bool
 // BEFORE:        cir.condition(%6)
 // BEFORE:      } body {
@@ -48,15 +48,15 @@ void alloca_in_loop(int* ar, int n) {
 // BEFORE:          %4 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
 // BEFORE:          %5 = cir.const #cir.int<4> : !s32i
 // BEFORE:          cir.store{{.*}} %5, %4 : !s32i, !cir.ptr<!s32i>
-// BEFORE:          %6 = cir.load %4 : !cir.ptr<!s32i>, !s32i
-// BEFORE:          %7 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
-// BEFORE:          %8 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// BEFORE:          %6 = cir.load{{.*}} %4 : !cir.ptr<!s32i>, !s32i
+// BEFORE:          %7 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// BEFORE:          %8 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // BEFORE:          %9 = cir.ptr_stride(%7 : !cir.ptr<!s32i>, %8 : !s32i), !cir.ptr<!s32i>
 // BEFORE:          cir.store{{.*}} %6, %9 : !s32i, !cir.ptr<!s32i>
 // BEFORE:        }
 // BEFORE:        cir.yield
 // BEFORE:      } step {
-// BEFORE:        %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %4 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // BEFORE:        %5 = cir.unary(inc, %4) nsw : !s32i, !s32i
 // BEFORE:        cir.store{{.*}} %5, %2 : !s32i, !cir.ptr<!s32i>
 // BEFORE:        cir.yield
@@ -112,34 +112,34 @@ int alloca_in_ifelse(int x) {
 // BEFORE:    %3 = cir.const #cir.int<0> : !s32i
 // BEFORE:    cir.store{{.*}} %3, %2 : !s32i, !cir.ptr<!s32i>
 // BEFORE:    cir.scope {
-// BEFORE:      %9 = cir.load %0 : !cir.ptr<!s32i>, !s32i
+// BEFORE:      %9 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
 // BEFORE:      %10 = cir.const #cir.int<42> : !s32i
 // BEFORE:      %11 = cir.cmp(gt, %9, %10) : !s32i, !cir.bool
 // BEFORE:      cir.if %11 {
 // BEFORE:        %12 = cir.alloca !s32i, !cir.ptr<!s32i>, ["z", init] {alignment = 4 : i64}
 // BEFORE:        %13 = cir.const #cir.int<2> : !s32i
 // BEFORE:        cir.store{{.*}} %13, %12 : !s32i, !cir.ptr<!s32i>
-// BEFORE:        %14 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-// BEFORE:        %15 = cir.load %12 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %14 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %15 = cir.load{{.*}} %12 : !cir.ptr<!s32i>, !s32i
 // BEFORE:        %16 = cir.binop(mul, %14, %15) nsw : !s32i
 // BEFORE:        cir.store{{.*}} %16, %2 : !s32i, !cir.ptr<!s32i>
 // BEFORE:      } else {
 // BEFORE:        %12 = cir.alloca !s32i, !cir.ptr<!s32i>, ["z", init] {alignment = 4 : i64}
 // BEFORE:        %13 = cir.const #cir.int<3> : !s32i
 // BEFORE:        cir.store{{.*}} %13, %12 : !s32i, !cir.ptr<!s32i>
-// BEFORE:        %14 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-// BEFORE:        %15 = cir.load %12 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %14 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
+// BEFORE:        %15 = cir.load{{.*}} %12 : !cir.ptr<!s32i>, !s32i
 // BEFORE:        %16 = cir.binop(mul, %14, %15) nsw : !s32i
 // BEFORE:        cir.store{{.*}} %16, %2 : !s32i, !cir.ptr<!s32i>
 // BEFORE:     }
 // BEFORE:    }
-// BEFORE:    %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// BEFORE:    %4 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // BEFORE:    %5 = cir.const #cir.int<1> : !s32i
 // BEFORE:    %6 = cir.binop(add, %4, %5) nsw : !s32i
 // BEFORE:    cir.store{{.*}} %6, %2 : !s32i, !cir.ptr<!s32i>
-// BEFORE:    %7 = cir.load %2 : !cir.ptr<!s32i>, !s32i
+// BEFORE:    %7 = cir.load{{.*}} %2 : !cir.ptr<!s32i>, !s32i
 // BEFORE:    cir.store{{.*}} %7, %1 : !s32i, !cir.ptr<!s32i>
-// BEFORE:    %8 = cir.load %1 : !cir.ptr<!s32i>, !s32i
+// BEFORE:    %8 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
 // BEFORE:    cir.return %8 : !s32i
 
 // MEM2REG:  cir.func {{.*@alloca_in_ifelse}}
@@ -179,7 +179,7 @@ void test_bitcast(size_t n) {
 // BEFORE:    %0 = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init] {alignment = 8 : i64}
 // BEFORE:    %1 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["c1", init] {alignment = 8 : i64}
 // BEFORE:    cir.store{{.*}} %arg0, %0 : !u64i, !cir.ptr<!u64i>
-// BEFORE:    %2 = cir.load %0 : !cir.ptr<!u64i>, !u64i
+// BEFORE:    %2 = cir.load{{.*}} %0 : !cir.ptr<!u64i>, !u64i
 // BEFORE:    %3 = cir.alloca !u8i, !cir.ptr<!u8i>, %2 : !u64i, ["bi_alloca"] {alignment = 16 : i64}
 // BEFORE:    %4 = cir.cast(bitcast, %3 : !cir.ptr<!u8i>), !cir.ptr<!void>
 // BEFORE:    %5 = cir.cast(bitcast, %4 : !cir.ptr<!void>), !cir.ptr<!s32i>
diff --git a/clang/test/CIR/Transforms/ternary-fold.cir b/clang/test/CIR/Transforms/ternary-fold.cir
index 72ba4815b2db..617a4e864b01 100644
--- a/clang/test/CIR/Transforms/ternary-fold.cir
+++ b/clang/test/CIR/Transforms/ternary-fold.cir
@@ -52,7 +52,7 @@ module {
   // CHECK-NEXT:     %[[#C:]] = cir.const #cir.int<42> : !s32i
   // CHECK-NEXT:     cir.yield %[[#C]] : !s32i
   // CHECK-NEXT:   }, false {
-  // CHECK-NEXT:     %[[#D:]] = cir.load %[[#A]] : !cir.ptr<!s32i>, !s32i
+  // CHECK-NEXT:     %[[#D:]] = cir.load{{.*}} %[[#A]] : !cir.ptr<!s32i>, !s32i
   // CHECK-NEXT:     cir.yield %[[#D]] : !s32i
   // CHECK-NEXT:   }) : (!cir.bool) -> !s32i
   // CHECK-NEXT:   cir.return %[[#B]] : !s32i
diff --git a/clang/test/CIR/Transforms/ternary-fold.cpp b/clang/test/CIR/Transforms/ternary-fold.cpp
index 350502e8b9b7..eadc74f99a17 100644
--- a/clang/test/CIR/Transforms/ternary-fold.cpp
+++ b/clang/test/CIR/Transforms/ternary-fold.cpp
@@ -34,7 +34,7 @@ int test2(bool cond) {
 }
 
 //      CIR-BEFORE: cir.func @_Z5test2b
-//      CIR-BEFORE:   %[[#COND:]] = cir.load %{{.+}} : !cir.ptr<!cir.bool>, !cir.bool
+//      CIR-BEFORE:   %[[#COND:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.bool>, !cir.bool
 // CIR-BEFORE-NEXT:   %{{.+}} = cir.ternary(%[[#COND]], true {
 // CIR-BEFORE-NEXT:     %[[#A:]] = cir.const #cir.int<1> : !s32i
 // CIR-BEFORE-NEXT:     cir.yield %[[#A]] : !s32i
@@ -45,7 +45,7 @@ int test2(bool cond) {
 //      CIR-BEFORE: }
 
 //      CIR-AFTER: cir.func @_Z5test2b
-//      CIR-AFTER:   %[[#COND:]] = cir.load %{{.+}} : !cir.ptr<!cir.bool>, !cir.bool
+//      CIR-AFTER:   %[[#COND:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.bool>, !cir.bool
 // CIR-AFTER-NEXT:   %[[#A:]] = cir.const #cir.int<1> : !s32i
 // CIR-AFTER-NEXT:   %[[#B:]] = cir.const #cir.int<2> : !s32i
 // CIR-AFTER-NEXT:   %{{.+}} = cir.select if %[[#COND]] then %[[#A]] else %[[#B]] : (!cir.bool, !s32i, !s32i) -> !s32i