diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index a70a9ce976a4..31c38241a6e6 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -225,9 +225,9 @@ def CIR_CastOp : CIR_Op<"cast",[
     Example:
 
     ```mlir
-    %4 = cir.cast(int_to_bool, %3 : i32), !cir.bool
+    %4 = cir.cast int_to_bool %3 : i32 -> !cir.bool
     ...
-    %x = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<i32 x 10>>), !cir.ptr<i32>
+    %x = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<i32 x 10>> -> !cir.ptr<i32>
     ```
   }];
 
@@ -235,8 +235,7 @@ def CIR_CastOp : CIR_Op<"cast",[
   let results = (outs CIR_AnyType:$result);
 
   let assemblyFormat = [{
-    `(` $kind `,` $src `:` type($src) `)`
-    `,` type($result) attr-dict
+    $kind $src `:` type($src) `->` type($result) attr-dict
   }];
 
   // The input and output types should match the cast kind.
@@ -4922,7 +4921,7 @@ def CIR_MemSetOp : CIR_Op<"libc.memset"> {
       // Set 2 bytes from a record to 0:
       %2 = cir.const #cir.int<2> : !u32i
       %3 = cir.const #cir.int<0> : !u32i
-      %zero = cir.cast(integral, %3 : !s32i), !u8i
+      %zero = cir.cast integral %3 : !s32i -> !u8i
       cir.libc.memset %2 bytes from %record set to %zero : !cir.ptr<!void>, !s32i, !u64i
     ```
   }];
@@ -5446,7 +5445,7 @@ def CIR_FreeExceptionOp : CIR_Op<"free.exception"> {
     %1 = cir.get_global @d2 : !cir.ptr<!some_record>
     cir.try synthetic cleanup {
       cir.call exception @_ZN7test2_DC1ERKS_(%0, %1) : (!cir.ptr<!some_record>, !cir.ptr<!some_record>) -> () cleanup {
-        %2 = cir.cast(bitcast, %0 : !cir.ptr<!some_record>), !cir.ptr<!void>
+        %2 = cir.cast bitcast %0 : !cir.ptr<!some_record> -> !cir.ptr<!void>
         cir.free.exception %2
         cir.yield
       }
@@ -5865,7 +5864,7 @@ def CIR_GotoOp : CIR_Op<"goto", [Terminator]> {
   ```mlir
     cir.scope {  // REGION #1
       %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-      %3 = cir.cast(int_to_bool, %2 : !s32i), !cir.bool
+      %3 = cir.cast int_to_bool %2 : !s32i -> !cir.bool
       cir.if %3 {
         cir.goto "label"
       }
diff --git a/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp
index 6a46c4bad600..3e96792694d7 100644
--- a/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/SCFPrepare.cpp
@@ -120,7 +120,7 @@ struct canonicalizeIVtoCmpLHS : public OpRewritePattern<ForOp> {
 //     %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
 //     %5 = cir.const #cir.int<100> : !s32i       <- upper bound
 //     %6 = cir.cmp(lt, %4, %5) : !s32i, !s32i
-//     %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool
+//     %7 = cir.cast int_to_bool %6 : !s32i -> !cir.bool
 //     cir.condition(%7
 //  } body {
 struct hoistLoopInvariantInCondBlock : public OpRewritePattern<ForOp> {
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
index fc7242d318c3..f3fc679e0cf1 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -4914,7 +4914,7 @@ void buildCtorDtorList(
 // For instance, the next CIR code:
 //
 //    cir.func @foo(%arg0: !s32i) -> !s32i {
-//      %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+//      %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
 //      cir.if %4 {
 //        %5 = cir.const #cir.int<1> : !s32i
 //        cir.return %5 : !s32i
diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp
index 5d2b4180571a..10a8c7e82939 100644
--- a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp
+++ b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp
@@ -1449,7 +1449,7 @@ class CIRPtrStrideOpLowering
   }
 
   // Rewrite
-  //        %0 = cir.cast(array_to_ptrdecay, %base)
+  //        %0 = cir.cast array_to_ptrdecay %base
   //        cir.ptr_stride(%0, %stride)
   // to
   //        memref.reinterpret_cast (%base, %stride)
diff --git a/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c b/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c
index 0fb0ae539061..3582523378f8 100644
--- a/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c
+++ b/clang/test/CIR/CallConvLowering/AArch64/aarch64-cc-structs.c
@@ -29,7 +29,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:   %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_LT_64> -> !cir.ptr<!u16i>
 // CHECK:   %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!u16i>, !u16i
 // CHECK:   cir.return %[[#V2]] : !u16i
 LT_64 ret_lt_64() {
@@ -39,7 +39,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:   %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_EQ_64> -> !cir.ptr<!u64i>
 // CHECK:   %[[#V2:]] = cir.load{{.*}} %[[#V1]] : !cir.ptr<!u64i>, !u64i
 // CHECK:   cir.return %[[#V2]] : !u64i
 EQ_64 ret_eq_64() {
@@ -49,7 +49,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:   %[[#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:   cir.return %[[#V2]] : !cir.array<!u64i x 2>
 LT_128 ret_lt_128() {
@@ -59,7 +59,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:   %[[#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:   cir.return %[[#V2]] : !cir.array<!u64i x 2>
 EQ_128 ret_eq_128() {
@@ -83,8 +83,8 @@ typedef struct {
 // CHECK: cir.func {{.*@retS}}() -> !cir.array<!u64i x 2>
 // CHECK:   %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval"] {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.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!void>
-// CHECK:   %[[#V3:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>), !cir.ptr<!void>
+// CHECK:   %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!void>
+// 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>
@@ -102,8 +102,8 @@ S retS() {
 }
 // CHECK: cir.func {{.*@pass_lt_64}}(%arg0: !u64
 // CHECK:   %[[#V0:]] = cir.alloca !rec_LT_64, !cir.ptr<!rec_LT_64>
-// CHECK:   %[[#V1:]] = cir.cast(integral, %arg0 : !u64i), !u16i
-// CHECK:   %[[#V2:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_LT_64>), !cir.ptr<!u16i>
+// CHECK:   %[[#V1:]] = cir.cast integral %arg0 : !u64i -> !u16i
+// CHECK:   %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_LT_64> -> !cir.ptr<!u16i>
 // CHECK:   cir.store{{.*}} %[[#V1]], %[[#V2]] : !u16i, !cir.ptr<!u16i>
 
 // LLVM: void @pass_lt_64(i64 %0)
@@ -114,7 +114,7 @@ void pass_lt_64(LT_64 s) {}
 
 // CHECK: cir.func {{.*@pass_eq_64}}(%arg0: !u64i
 // CHECK:   %[[#V0:]] = cir.alloca !rec_EQ_64, !cir.ptr<!rec_EQ_64>
-// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_EQ_64>), !cir.ptr<!u64i>
+// CHECK:   %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_EQ_64> -> !cir.ptr<!u64i>
 // CHECK:   cir.store{{.*}} %arg0, %[[#V1]] : !u64i, !cir.ptr<!u64i>
 
 // LLVM: void @pass_eq_64(i64 %0)
@@ -124,7 +124,7 @@ void pass_eq_64(EQ_64 s) {}
 
 // CHECK: cir.func {{.*@pass_lt_128}}(%arg0: !cir.array<!u64i x 2>
 // CHECK:   %[[#V0:]] = cir.alloca !rec_LT_128, !cir.ptr<!rec_LT_128>
-// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_LT_128>), !cir.ptr<!cir.array<!u64i x 2>>
+// CHECK:   %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_LT_128> -> !cir.ptr<!cir.array<!u64i x 2>>
 // CHECK:   cir.store{{.*}} %arg0, %[[#V1]] : !cir.array<!u64i x 2>, !cir.ptr<!cir.array<!u64i x 2>>
 
 // LLVM: void @pass_lt_128([2 x i64] %0)
@@ -134,7 +134,7 @@ void pass_lt_128(LT_128 s) {}
 
 // CHECK: cir.func {{.*@pass_eq_128}}(%arg0: !cir.array<!u64i x 2>
 // CHECK:   %[[#V0:]] = cir.alloca !rec_EQ_128, !cir.ptr<!rec_EQ_128>
-// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_EQ_128>), !cir.ptr<!cir.array<!u64i x 2>>
+// CHECK:   %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_EQ_128> -> !cir.ptr<!cir.array<!u64i x 2>>
 // CHECK:   cir.store{{.*}} %arg0, %[[#V1]] : !cir.array<!u64i x 2>, !cir.ptr<!cir.array<!u64i x 2>>
 
 // LLVM: void @pass_eq_128([2 x i64] %0)
@@ -175,8 +175,8 @@ GT_128 get_gt_128(GT_128 s) {
 // 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>
-// CHECK: %[[#V5:]] = cir.cast(bitcast, %[[#V3]] : !cir.ptr<!rec_GT_128>), !cir.ptr<!void>
+// CHECK: %[[#V4:]] = cir.cast bitcast %arg0 : !cir.ptr<!rec_GT_128> -> !cir.ptr<!void>
+// CHECK: %[[#V5:]] = cir.cast bitcast %[[#V3]] : !cir.ptr<!rec_GT_128> -> !cir.ptr<!void>
 // CHECK: %[[#V6:]] = cir.const #cir.int<24> : !u64i
 // CHECK: cir.libc.memcpy %[[#V6]] bytes from %[[#V4]] to %[[#V5]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 // CHECK: cir.call @get_gt_128(%[[#V2]], %[[#V3]]) : (!cir.ptr<!rec_GT_128>, !cir.ptr<!rec_GT_128>) -> ()
@@ -198,8 +198,8 @@ GT_128 call_and_get_gt_128() {
 // CHECK:   %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_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:   cir.store{{.*}} %arg0, %[[#V1]] : !cir.array<!u64i x 2>, !cir.ptr<!cir.array<!u64i x 2>>
-// CHECK:   %[[#V2:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>), !cir.ptr<!void>
-// CHECK:   %[[#V3:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!void>
+// CHECK:   %[[#V2:]] = cir.cast bitcast %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>> -> !cir.ptr<!void>
+// CHECK:   %[[#V3:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !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>
 
@@ -214,8 +214,8 @@ void passS(S s) {}
 // 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: %[[#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: %[[#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>
@@ -245,8 +245,8 @@ typedef struct {
 // 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: %[[#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: %[[#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>
@@ -292,8 +292,8 @@ typedef struct {
 
 // CHECK: cir.func dso_local @pass_nested_u(%arg0: !u64i
 // CHECK: %[[#V0:]] = cir.alloca !rec_NESTED_U, !cir.ptr<!rec_NESTED_U>, [""] {alignment = 4 : i64}
-// CHECK: %[[#V1:]] = cir.cast(integral, %arg0 : !u64i), !u16i
-// CHECK: %[[#V2:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_NESTED_U>
+// CHECK: %[[#V1:]] = cir.cast integral %arg0 : !u64i -> !u16i
+// CHECK: %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_NESTED_U>
 // CHECK: cir.store{{.*}} %[[#V1]], %[[#V2]] : !u16i
 // CHECK: cir.return
 
@@ -308,12 +308,12 @@ void pass_nested_u(NESTED_U a) {}
 // 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: %[[#V3:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_NESTED_U>), !cir.ptr<!rec_anon2E0>
+// 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: %[[#V5:]] = cir.cast(bitcast, %[[#V3]] : !cir.ptr<!rec_anon2E0>), !cir.ptr<!rec_anon2E1>
+// 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: %[[#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: %[[#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
@@ -360,8 +360,8 @@ void bar(void) {
 // CHECK: %[[#V1:]] = cir.alloca !cir.array<!u64i x 2>, !cir.ptr<!cir.array<!u64i x 2>>, ["tmp"]
 // CHECK: %[[#V2:]] = cir.call @foo() : () -> !cir.array<!u64i x 2>
 // CHECK: cir.store{{.*}} %[[#V2]], %[[#V1]] : !cir.array<!u64i x 2>, !cir.ptr<!cir.array<!u64i x 2>>
-// CHECK: %[[#V3:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>>), !cir.ptr<!void>
-// CHECK: %[[#V4:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_PackedS1>), !cir.ptr<!void>
+// CHECK: %[[#V3:]] = cir.cast bitcast %[[#V1]] : !cir.ptr<!cir.array<!u64i x 2>> -> !cir.ptr<!void>
+// CHECK: %[[#V4:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_PackedS1> -> !cir.ptr<!void>
 // CHECK: %[[#V5:]] = cir.const #cir.int<14> : !u64i
 // CHECK: cir.libc.memcpy %[[#V5]] bytes from %[[#V3]] to %[[#V4]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 
@@ -402,7 +402,7 @@ void qux(void) {
 // CHECK: %[[#V5:]] = cir.get_element %[[#V2]][%[[#V3]]] : (!cir.ptr<!cir.array<!rec_PackedS2 x 3>>, !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: %[[#V7:]] = cir.cast(bitcast, %[[#V6]] : !cir.ptr<!rec_PackedS2>), !cir.ptr<!void>
+// 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/AArch64/aarch64_be-cc-structs.c b/clang/test/CIR/CallConvLowering/AArch64/aarch64_be-cc-structs.c
index 31fcdaf8d709..e579c749d8da 100644
--- a/clang/test/CIR/CallConvLowering/AArch64/aarch64_be-cc-structs.c
+++ b/clang/test/CIR/CallConvLowering/AArch64/aarch64_be-cc-structs.c
@@ -8,7 +8,7 @@ typedef struct {
 
 // CHECK: cir.func {{.*@init}}() -> !u64i
 // CHECK:    %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval"] {alignment = 4 : i64}
-// CHECK:    %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CHECK:    %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CHECK:    %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!u64i>, !u64i
 // CHECK:    cir.return %[[#V2]] : !u64i
 S init() {
diff --git a/clang/test/CIR/CallConvLowering/AArch64/ptr-fields.c b/clang/test/CIR/CallConvLowering/AArch64/ptr-fields.c
index e225daa8f8cd..a28c50f85127 100644
--- a/clang/test/CIR/CallConvLowering/AArch64/ptr-fields.c
+++ b/clang/test/CIR/CallConvLowering/AArch64/ptr-fields.c
@@ -13,7 +13,7 @@ int foo(int x) { return x; }
 
 // CIR: cir.func dso_local @passA(%arg0: !u64i
 // CIR: %[[#V0:]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, [""] {alignment = 4 : i64}
-// CIR: %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_A>), !cir.ptr<!u64i>
+// CIR: %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_A> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} %arg0, %[[#V1]] : !u64i, !cir.ptr<!u64i>
 // CIR: %[[#V2:]] = cir.get_global @foo : !cir.ptr<!cir.func<(!s32i) -> !s32i>>
 // CIR: %[[#V3:]] = cir.get_member %[[#V0]][0] {name = "f"} : !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i) -> !s32i>>>
@@ -38,7 +38,7 @@ typedef struct {
 
 // CIR: cir.func dso_local @passB(%arg0: !u64i
 // CIR: %[[#V0:]]  = cir.alloca !rec_S_2, !cir.ptr<!rec_S_2>, [""] {alignment = 4 : i64}
-// CIR: %[[#V1:]]  = cir.cast(bitcast, %[[#V0]]  : !cir.ptr<!rec_S_2>), !cir.ptr<!u64i>
+// CIR: %[[#V1:]]  = cir.cast bitcast %[[#V0]]  : !cir.ptr<!rec_S_2> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} %arg0, %[[#V1]]  : !u64i, !cir.ptr<!u64i>
 // CIR: cir.return
 
diff --git a/clang/test/CIR/CallConvLowering/AArch64/struct.c b/clang/test/CIR/CallConvLowering/AArch64/struct.c
index f73fbbcc4aa7..5b66ed1be1c5 100644
--- a/clang/test/CIR/CallConvLowering/AArch64/struct.c
+++ b/clang/test/CIR/CallConvLowering/AArch64/struct.c
@@ -9,7 +9,7 @@ typedef struct {
 
 // CIR: cir.func dso_local @init(%arg0: !u64i
 // CIR: %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, [""] {alignment = 4 : i64}
-// CIR: %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} %arg0, %[[#V1]] : !u64i, !cir.ptr<!u64i>
 // CIR: %[[#V2:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval"] {alignment = 4 : i64}
 // CIR: %[[#V3:]] = cir.const #cir.int<1> : !s32i
@@ -19,7 +19,7 @@ typedef struct {
 // CIR: %[[#V6:]] = cir.get_member %[[#V0]][1] {name = "b"} : !cir.ptr<!rec_S> -> !cir.ptr<!s32i>
 // CIR: cir.store{{.*}} %[[#V5]], %[[#V6]] : !s32i, !cir.ptr<!s32i>
 // CIR: cir.copy %[[#V0]] to %[[#V2]] : !cir.ptr<!rec_S>
-// CIR: %[[#V7:]] = cir.cast(bitcast, %[[#V2]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V7:]] = cir.cast bitcast %[[#V2]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: %[[#V8:]] = cir.load %[[#V7]] : !cir.ptr<!u64i>, !u64i
 // CIR: cir.return %[[#V8]] : !u64i
 
@@ -43,10 +43,10 @@ S init(S s) {
 // CIR: cir.func no_proto dso_local @foo1
 // CIR: %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s"]
 // CIR: %[[#V1:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["tmp"] {alignment = 4 : i64}
-// CIR: %[[#V2:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: %[[#V3:]] = cir.load %[[#V2]] : !cir.ptr<!u64i>, !u64i
 // CIR: %[[#V4:]] = cir.call @init(%[[#V3]]) : (!u64i) -> !u64i
-// CIR: %[[#V5:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V5:]] = cir.cast bitcast %[[#V1]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} %[[#V4]], %[[#V5]] : !u64i, !cir.ptr<!u64i>
 // CIR: cir.copy %[[#V1]] to %[[#V0]] : !cir.ptr<!rec_S>
 // CIR: cir.return
@@ -65,21 +65,21 @@ void foo1() {
 
 // CIR: cir.func dso_local @foo2(%arg0: !u64i
 // CIR: %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, [""] {alignment = 4 : i64}
-// CIR: %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} %arg0, %[[#V1]] : !u64i, !cir.ptr<!u64i>
 // CIR: %[[#V2:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval"] {alignment = 4 : i64}
 // CIR: %[[#V3:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s2"]
 // CIR: %[[#V4:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["tmp"] {alignment = 4 : i64}
 // CIR: %[[#V5:]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !rec_S
 // CIR: cir.store{{.*}} %[[#V5]], %[[#V3]] : !rec_S, !cir.ptr<!rec_S>
-// CIR: %[[#V6:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V6:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: %[[#V7:]] = cir.load %[[#V6]] : !cir.ptr<!u64i>, !u64i
 // CIR: %[[#V8:]] = cir.call @foo2(%[[#V7]]) : (!u64i) -> !u64i
-// CIR: %[[#V9:]] = cir.cast(bitcast, %[[#V4]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V9:]] = cir.cast bitcast %[[#V4]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: cir.store{{.*}} %[[#V8]], %[[#V9]] : !u64i, !cir.ptr<!u64i>
 // CIR: cir.copy %[[#V4]] to %[[#V0]] : !cir.ptr<!rec_S>
 // CIR: cir.copy %[[#V0]] to %[[#V2]] : !cir.ptr<!rec_S>
-// CIR: %[[#V10:]] = cir.cast(bitcast, %[[#V2]] : !cir.ptr<!rec_S>), !cir.ptr<!u64i>
+// CIR: %[[#V10:]] = cir.cast bitcast %[[#V2]] : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
 // CIR: %[[#V11:]] = cir.load %[[#V10]] : !cir.ptr<!u64i>, !u64i
 // CIR: cir.return %[[#V11]] : !u64i
 
@@ -110,19 +110,19 @@ typedef struct {
 
 // CIR: cir.func dso_local @init2(%arg0: !u16i
 // CIR: %[[#V0:]] = cir.alloca !rec_S2, !cir.ptr<!rec_S2>, [""] {alignment = 4 : i64}
-// CIR: %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S2>), !cir.ptr<!u16i>
+// CIR: %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: cir.store{{.*}} %arg0, %[[#V1]] : !u16i, !cir.ptr<!u16i>
 // CIR: %[[#V2:]] = cir.alloca !rec_S2, !cir.ptr<!rec_S2>, ["__retval"] {alignment = 1 : i64}
 // CIR: %[[#V3:]] = cir.const #cir.int<1> : !s32i
-// CIR: %[[#V4:]] = cir.cast(integral, %[[#V3]] : !s32i), !s8i
+// CIR: %[[#V4:]] = cir.cast integral %[[#V3]] : !s32i -> !s8i
 // CIR: %[[#V5:]] = cir.get_member %[[#V0]][0] {name = "a"} : !cir.ptr<!rec_S2> -> !cir.ptr<!s8i>
 // CIR: cir.store{{.*}} %[[#V4]], %[[#V5]] : !s8i, !cir.ptr<!s8i>
 // CIR: %[[#V6:]] = cir.const #cir.int<2> : !s32i
-// CIR: %[[#V7:]] = cir.cast(integral, %[[#V6]] : !s32i), !s8i
+// CIR: %[[#V7:]] = cir.cast integral %[[#V6]] : !s32i -> !s8i
 // CIR: %[[#V8:]] = cir.get_member %[[#V0]][1] {name = "b"} : !cir.ptr<!rec_S2> -> !cir.ptr<!s8i>
 // CIR: cir.store{{.*}} %[[#V7]], %[[#V8]] : !s8i, !cir.ptr<!s8i>
 // CIR: cir.copy %[[#V0]] to %[[#V2]] : !cir.ptr<!rec_S2>
-// CIR: %[[#V9:]] = cir.cast(bitcast, %[[#V2]] : !cir.ptr<!rec_S2>), !cir.ptr<!u16i>
+// CIR: %[[#V9:]] = cir.cast bitcast %[[#V2]] : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: %[[#V10:]] = cir.load %[[#V9]] : !cir.ptr<!u16i>, !u16i
 // CIR: cir.return %[[#V10]] : !u16i
 
@@ -146,10 +146,10 @@ S2 init2(S2 s) {
 // CIR: cir.func no_proto dso_local @foo3()
 // CIR: %[[#V0:]] = cir.alloca !rec_S2, !cir.ptr<!rec_S2>, ["s"]
 // CIR: %[[#V1:]] = cir.alloca !rec_S2, !cir.ptr<!rec_S2>, ["tmp"] {alignment = 1 : i64}
-// CIR: %[[#V2:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S2>), !cir.ptr<!u16i>
+// CIR: %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: %[[#V3:]] = cir.load %[[#V2]] : !cir.ptr<!u16i>, !u16i
 // CIR: %[[#V4:]] = cir.call @init2(%[[#V3]]) : (!u16i) -> !u16i
-// CIR: %[[#V5:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!rec_S2>), !cir.ptr<!u16i>
+// CIR: %[[#V5:]] = cir.cast bitcast %[[#V1]] : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: cir.store{{.*}} %[[#V4]], %[[#V5]] : !u16i, !cir.ptr<!u16i>
 // CIR: cir.copy %[[#V1]] to %[[#V0]] : !cir.ptr<!rec_S2>
 // CIR: cir.return
diff --git a/clang/test/CIR/CallConvLowering/AArch64/union.c b/clang/test/CIR/CallConvLowering/AArch64/union.c
index 040e7de31f09..feeb054aeb00 100644
--- a/clang/test/CIR/CallConvLowering/AArch64/union.c
+++ b/clang/test/CIR/CallConvLowering/AArch64/union.c
@@ -11,8 +11,8 @@ typedef union {
 
 // CIR: cir.func dso_local @foo(%arg0: !u64i
 // CIR: %[[#V0:]] = cir.alloca !rec_U, !cir.ptr<!rec_U>, [""] {alignment = 4 : i64}
-// CIR: %[[#V1:]] = cir.cast(integral, %arg0 : !u64i), !u32i
-// CIR: %[[#V2:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_U>), !cir.ptr<!u32i>
+// CIR: %[[#V1:]] = cir.cast integral %arg0 : !u64i -> !u32i
+// CIR: %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_U> -> !cir.ptr<!u32i>
 // CIR: cir.store %[[#V1]], %[[#V2]] : !u32i, !cir.ptr<!u32i>
 // CIR: cir.return
 
@@ -26,7 +26,7 @@ void foo(U u) {}
 // CIR: cir.func no_proto dso_local @init() -> !u32i
 // CIR: %[[#V0:]] = cir.alloca !rec_U, !cir.ptr<!rec_U>, ["__retval"] {alignment = 4 : i64}
 // CIR: %[[#V1:]] = cir.load %[[#V0]] : !cir.ptr<!rec_U>, !rec_U
-// CIR: %[[#V2:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_U>), !cir.ptr<!u32i>
+// CIR: %[[#V2:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_U> -> !cir.ptr<!u32i>
 // CIR: %[[#V3:]] = cir.load %[[#V2]] : !cir.ptr<!u32i>, !u32i
 // CIR: cir.return %[[#V3]] : !u32i
 
@@ -55,9 +55,9 @@ void passA(A x) {}
 
 // CIR: cir.func {{.*@callA}}()
 // CIR:   %[[#V0:]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["x"] {alignment = 4 : i64}
-// CIR:   %[[#V1:]] = cir.cast(bitcast, %[[#V0:]] : !cir.ptr<!rec_A>), !cir.ptr<!s32i>
+// CIR:   %[[#V1:]] = cir.cast bitcast %[[#V0:]] : !cir.ptr<!rec_A> -> !cir.ptr<!s32i>
 // CIR:   %[[#V2:]] = cir.load %[[#V1]] : !cir.ptr<!s32i>, !s32i
-// CIR:   %[[#V3:]] = cir.cast(integral, %[[#V2]] : !s32i), !u64i
+// CIR:   %[[#V3:]] = cir.cast integral %[[#V2]] : !s32i -> !u64i
 // CIR:   cir.call @passA(%[[#V3]]) : (!u64i) -> ()
 
 // LLVM: void @callA()
diff --git a/clang/test/CIR/CallConvLowering/x86_64/basic.cpp b/clang/test/CIR/CallConvLowering/x86_64/basic.cpp
index b7a25fd57de0..bacea3fa19fe 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/basic.cpp
+++ b/clang/test/CIR/CallConvLowering/x86_64/basic.cpp
@@ -100,7 +100,7 @@ struct S1 {
 
 /// Cast arguments to the expected type.
 // CHECK: %[[#V0:]] = cir.alloca !rec_S1, !cir.ptr<!rec_S1>, [""] {alignment = 4 : i64}
-// CHECK: %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S1>), !cir.ptr<!u64i>
+// CHECK: %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S1> -> !cir.ptr<!u64i>
 // CHECK: cir.store{{.*}} %arg0, %[[#V1]] : !u64i, !cir.ptr<!u64i>
 // CHECK: %[[#V2:]] = cir.alloca !rec_S1, !cir.ptr<!rec_S1>, ["__retval"] {alignment = 4 : i64}
 // CHECK: %[[#V3:]] = cir.alloca !rec_S1, !cir.ptr<!rec_S1>, ["agg.tmp0"] {alignment = 4 : i64}
@@ -108,10 +108,10 @@ struct S1 {
 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: %[[#V9:]] = cir.cast bitcast %[[#V3]] : !cir.ptr<!rec_S1> -> !cir.ptr<!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: %[[#V12:]] = cir.cast bitcast %[[#V4]] : !cir.ptr<!rec_S1> -> !cir.ptr<!u64i>
   // CHECK: cir.store{{.*}} %[[#V11]], %[[#V12]] : !u64i, !cir.ptr<!u64i>
   s1({1, 2});
 
@@ -121,7 +121,7 @@ S1 s1(S1 arg) {
   // CHECK: %[[#V15:]] = cir.get_member %[[#V2]][1] {name = "b"} : !cir.ptr<!rec_S1> -> !cir.ptr<!s32i>
   // 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: %[[#V17:]] = cir.cast bitcast %[[#V2]] : !cir.ptr<!rec_S1> -> !cir.ptr<!u64i>
   // CHECK: %[[#V18:]] = cir.load{{.*}} %[[#V17]] : !cir.ptr<!u64i>, !u64i
   // CHECK: cir.return %[[#V18]] : !u64i
   return {1, 2};
@@ -142,8 +142,8 @@ struct S2 {
 // CHECK: cir.store{{.*}} %[[ARG0]], %[[#F2]] : !u64i, !cir.ptr<!u64i>
 // CHECK: %[[#F3:]] = cir.get_member %[[#F1]][1]{{.*}} : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!s32i>
 // CHECK: cir.store{{.*}} %[[ARG1]], %[[#F3]] : !s32i, !cir.ptr<!s32i>
-// CHECK: %[[#F4:]] = cir.cast(bitcast, %[[#F1]] : !cir.ptr<!rec_anon_struct>), !cir.ptr<!void>
-// CHECK: %[[#F5:]] = cir.cast(bitcast, %[[#F0]] : !cir.ptr<!rec_S2>), !cir.ptr<!void>
+// CHECK: %[[#F4:]] = cir.cast bitcast %[[#F1]] : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!void>
+// CHECK: %[[#F5:]] = cir.cast bitcast %[[#F0]] : !cir.ptr<!rec_S2> -> !cir.ptr<!void>
 // CHECK: %[[#F6:]] = cir.const #cir.int<12> : !u64i
 // CHECK: cir.libc.memcpy %[[#F6]] bytes from %[[#F4]] to %[[#F5]]
 S2 s2(S2 arg) {
@@ -172,8 +172,8 @@ S2 s2(S2 arg) {
 
   // 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>
+  // 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>
   // CHECK: %[[#F23:]] = cir.const #cir.int<12> : !u64i
   // CHECK: cir.libc.memcpy %[[#F23]] bytes from %[[#F21]] to %[[#F22]]
 
@@ -187,8 +187,8 @@ S2 s2(S2 arg) {
   // 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>
 
-  // CHECK: %[[#F29:]] = cir.cast(bitcast, %[[#F12]] : !cir.ptr<!rec_anon_struct>), !cir.ptr<!void>
-  // CHECK: %[[#F30:]] = cir.cast(bitcast, %[[#F9]] : !cir.ptr<!rec_S2>), !cir.ptr<!void>
+  // CHECK: %[[#F29:]] = cir.cast bitcast %[[#F12]] : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!void>
+  // CHECK: %[[#F30:]] = cir.cast bitcast %[[#F9]] : !cir.ptr<!rec_S2> -> !cir.ptr<!void>
   // CHECK: %[[#F31:]] = cir.const #cir.int<12> : !u64i
   // CHECK: cir.libc.memcpy %[[#F31]] bytes from %[[#F29]] to %[[#F30]]
 
@@ -197,8 +197,8 @@ S2 s2(S2 arg) {
 
   // COM: For return, the first two fields of S2 is also coerced.
 
-  // CHECK: %[[#F39:]] = cir.cast(bitcast, %[[#F7]] : !cir.ptr<!rec_S2>), !cir.ptr<!void>
-  // CHECK: %[[#F40:]] = cir.cast(bitcast, %[[#F13]] : !cir.ptr<!rec_anon_struct>), !cir.ptr<!void>
+  // CHECK: %[[#F39:]] = cir.cast bitcast %[[#F7]] : !cir.ptr<!rec_S2> -> !cir.ptr<!void>
+  // 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
diff --git a/clang/test/CIR/CallConvLowering/x86_64/fptrs.c b/clang/test/CIR/CallConvLowering/x86_64/fptrs.c
index 3ec9ed4b8f4f..38891d81b2c8 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/fptrs.c
+++ b/clang/test/CIR/CallConvLowering/x86_64/fptrs.c
@@ -12,7 +12,7 @@ int foo(S s) { return 42 + s.a; }
 // CHECK: cir.func {{.*@bar}}
 // CHECK:   %[[#V0:]] = cir.alloca !cir.ptr<!cir.func<(!rec_S) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!rec_S) -> !s32i>>>, ["a", init]
 // CHECK:   %[[#V1:]] = cir.get_global @foo : !cir.ptr<!cir.func<(!s32i) -> !s32i>>
-// CHECK:   %[[#V2:]] = cir.cast(bitcast, %[[#V1]] : !cir.ptr<!cir.func<(!s32i) -> !s32i>>), !cir.ptr<!cir.func<(!rec_S) -> !s32i>>
+// CHECK:   %[[#V2:]] = cir.cast bitcast %[[#V1]] : !cir.ptr<!cir.func<(!s32i) -> !s32i>> -> !cir.ptr<!cir.func<(!rec_S) -> !s32i>>
 // CHECK:   cir.store{{.*}} %[[#V2]], %[[#V0]] : !cir.ptr<!cir.func<(!rec_S) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!rec_S) -> !s32i>>>
 void bar() {
   myfptr a = foo;
@@ -20,16 +20,16 @@ void bar() {
 
 // CHECK: cir.func {{.*@baz}}(%arg0: !s32i
 // CHECK:   %[[#V0:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, [""] {alignment = 4 : i64}
-// CHECK:   %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!s32i>
+// CHECK:   %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!s32i>
 // CHECK:   cir.store{{.*}} %arg0, %[[#V1]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   %[[#V2:]] = cir.alloca !cir.ptr<!cir.func<(!rec_S) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!rec_S) -> !s32i>>>, ["a", init]
 // 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:   %[[#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:   %[[#V6:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_S>), !cir.ptr<!s32i>
+// CHECK:   %[[#V6:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_S> -> !cir.ptr<!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:   %[[#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
 
 // LLVM: define dso_local void @baz(i32 %0)
diff --git a/clang/test/CIR/CallConvLowering/x86_64/int128.cpp b/clang/test/CIR/CallConvLowering/x86_64/int128.cpp
index 5f9cff51d521..c2d1c750eeff 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/int128.cpp
+++ b/clang/test/CIR/CallConvLowering/x86_64/int128.cpp
@@ -9,13 +9,13 @@
 // LLVM: define dso_local { i64, i64 } @_Z5test1nn(i64 %[[#A_LO:]], i64 %[[#A_HI:]], i64 %[[#B_LO:]], i64 %[[#B_HI:]])
 __int128 test1(__int128 a, __int128 b) {
   //      CHECK: %[[#SLOT_A:]] = cir.alloca !s128i, !cir.ptr<!s128i>
-  // CHECK-NEXT: %[[#SLOT_A2:]] = cir.cast(bitcast, %[[#SLOT_A]] : !cir.ptr<!s128i>), !cir.ptr<![[I128_STRUCT]]>
+  // CHECK-NEXT: %[[#SLOT_A2:]] = cir.cast bitcast %[[#SLOT_A]] : !cir.ptr<!s128i> -> !cir.ptr<![[I128_STRUCT]]>
   // CHECK-NEXT: %[[#SLOT_A_LO:]] = cir.get_member %[[#SLOT_A2]][0] {name = ""} : !cir.ptr<![[I128_STRUCT]]> -> !cir.ptr<!s64i>
   // CHECK-NEXT: cir.store %[[ARG0]], %[[#SLOT_A_LO]] : !s64i, !cir.ptr<!s64i>
   // CHECK-NEXT: %[[#SLOT_A_HI:]] = cir.get_member %[[#SLOT_A2]][1] {name = ""} : !cir.ptr<![[I128_STRUCT]]> -> !cir.ptr<!s64i>
   // CHECK-NEXT: cir.store %arg1, %[[#SLOT_A_HI]] : !s64i, !cir.ptr<!s64i>
   // CHECK-NEXT: %[[#SLOT_B:]] = cir.alloca !s128i, !cir.ptr<!s128i>
-  // CHECK-NEXT: %[[#SLOT_B2:]] = cir.cast(bitcast, %[[#SLOT_B]] : !cir.ptr<!s128i>), !cir.ptr<![[I128_STRUCT]]>
+  // CHECK-NEXT: %[[#SLOT_B2:]] = cir.cast bitcast %[[#SLOT_B]] : !cir.ptr<!s128i> -> !cir.ptr<![[I128_STRUCT]]>
   // CHECK-NEXT: %[[#SLOT_B_LO:]] = cir.get_member %[[#SLOT_B2]][0] {name = ""} : !cir.ptr<![[I128_STRUCT]]> -> !cir.ptr<!s64i>
   // CHECK-NEXT: cir.store %arg2, %[[#SLOT_B_LO]] : !s64i, !cir.ptr<!s64i>
   // CHECK-NEXT: %[[#SLOT_B_HI:]] = cir.get_member %[[#SLOT_B2]][1] {name = ""} : !cir.ptr<![[I128_STRUCT]]> -> !cir.ptr<!s64i>
@@ -45,7 +45,7 @@ __int128 test1(__int128 a, __int128 b) {
   // LLVM-NEXT: %[[#SUM:]] = add nsw i128 %[[#A]], %[[#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: %[[#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: cir.return %[[#RET]] : ![[I128_STRUCT]]
 
diff --git a/clang/test/CIR/CallConvLowering/x86_64/varargs.c b/clang/test/CIR/CallConvLowering/x86_64/varargs.c
index fdc505aa6c5f..97522aed8b55 100644
--- a/clang/test/CIR/CallConvLowering/x86_64/varargs.c
+++ b/clang/test/CIR/CallConvLowering/x86_64/varargs.c
@@ -8,7 +8,7 @@ int printf(const char *str, ...);
 // CHECK:   cir.store %arg0, %[[#V0]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   cir.store %arg1, %[[#V1]] : !s32i, !cir.ptr<!s32i>
 // CHECK:   %[[#V2:]] = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 7>>
-// CHECK:   %[[#V3:]] = cir.cast(array_to_ptrdecay, %[[#V2]] : !cir.ptr<!cir.array<!s8i x 7>>), !cir.ptr<!s8i>
+// CHECK:   %[[#V3:]] = cir.cast array_to_ptrdecay %[[#V2]] : !cir.ptr<!cir.array<!s8i x 7>> -> !cir.ptr<!s8i>
 // CHECK:   %[[#V4:]] = cir.load %[[#V1]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[#V5:]] = cir.load %[[#V2]] : !cir.ptr<!s32i>, !s32i
 // CHECK:   %[[#V6:]] = cir.call @printf(%[[#V3]], %[[#V4]], %[[#V5]]) : (!cir.ptr<!s8i>, !s32i, !s32i) -> !s32i
diff --git a/clang/test/CIR/CodeGen/AArch64/neon-arith.c b/clang/test/CIR/CodeGen/AArch64/neon-arith.c
index 03362c4c5eeb..439621cb8ca8 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon-arith.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon-arith.c
@@ -115,7 +115,7 @@ int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) {
 // CIR-LABEL: vpadd_s16
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!s16i x 4>, !cir.vector<!s16i x 4>) -> !cir.vector<!s16i x 4>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!s16i x 4>), !cir.vector<!s8i x 8>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!s16i x 4> -> !cir.vector<!s8i x 8>
 
 // LLVM: {{.*}}test_vpadd_s16(<4 x i16>{{.*}}[[A:%.*]], <4 x i16>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <4 x i16> @llvm.aarch64.neon.addp.v4i16(<4 x i16> [[A]], <4 x i16> [[B]])
@@ -128,7 +128,7 @@ int16x8_t test_vpaddq_s16(int16x8_t a, int16x8_t b) {
 // CIR-LABEL: vpaddq_s16
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!s16i x 8>, !cir.vector<!s16i x 8>) -> !cir.vector<!s16i x 8>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!s16i x 8>), !cir.vector<!s8i x 16>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!s16i x 8> -> !cir.vector<!s8i x 16>
 
 // LLVM: {{.*}}test_vpaddq_s16(<8 x i16>{{.*}}[[A:%.*]], <8 x i16>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <8 x i16> @llvm.aarch64.neon.addp.v8i16(<8 x i16> [[A]], <8 x i16> [[B]])
@@ -141,7 +141,7 @@ uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) {
 // CIR-LABEL: vpadd_u16
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!u16i x 4>, !cir.vector<!u16i x 4>) -> !cir.vector<!u16i x 4>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!u16i x 4>), !cir.vector<!s8i x 8>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!u16i x 4> -> !cir.vector<!s8i x 8>
 
 // LLVM: {{.*}}test_vpadd_u16(<4 x i16>{{.*}}[[A:%.*]], <4 x i16>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <4 x i16> @llvm.aarch64.neon.addp.v4i16(<4 x i16> [[A]], <4 x i16> [[B]])
@@ -154,7 +154,7 @@ int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) {
 // CIR-LABEL: vpadd_s32
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!s32i x 2>, !cir.vector<!s32i x 2>) -> !cir.vector<!s32i x 2>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!s32i x 2>), !cir.vector<!s8i x 8>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!s32i x 2> -> !cir.vector<!s8i x 8>
 
 // LLVM: {{.*}}test_vpadd_s32(<2 x i32>{{.*}}[[A:%.*]], <2 x i32>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <2 x i32> @llvm.aarch64.neon.addp.v2i32(<2 x i32> [[A]], <2 x i32> [[B]])
@@ -167,7 +167,7 @@ int32x4_t test_vpaddq_s32(int32x4_t a, int32x4_t b) {
 // CIR-LABEL: vpaddq_s32
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>) -> !cir.vector<!s32i x 4>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!s32i x 4>), !cir.vector<!s8i x 16>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!s32i x 4> -> !cir.vector<!s8i x 16>
 
 // LLVM: {{.*}}test_vpaddq_s32(<4 x i32>{{.*}}[[A:%.*]], <4 x i32>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <4 x i32> @llvm.aarch64.neon.addp.v4i32(<4 x i32> [[A]], <4 x i32> [[B]])
@@ -180,7 +180,7 @@ float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) {
 // CIR-LABEL: vpadd_f32
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!cir.float x 2>, !cir.vector<!cir.float x 2>) -> !cir.vector<!cir.float x 2>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!cir.float x 2>), !cir.vector<!s8i x 8>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!cir.float x 2> -> !cir.vector<!s8i x 8>
 
 // LLVM: {{.*}}test_vpadd_f32(<2 x float>{{.*}}[[A:%.*]], <2 x float>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <2 x float> @llvm.aarch64.neon.faddp.v2f32(<2 x float> [[A]], <2 x float> [[B]])
@@ -193,7 +193,7 @@ float32x4_t test_vpaddq_f32(float32x4_t a, float32x4_t b) {
 // CIR-LABEL: vpaddq_f32
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!cir.float x 4>, !cir.vector<!cir.float x 4>) -> !cir.vector<!cir.float x 4>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!cir.float x 4>), !cir.vector<!s8i x 16>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!cir.float x 4> -> !cir.vector<!s8i x 16>
 
 // LLVM: {{.*}}test_vpaddq_f32(<4 x float>{{.*}}[[A:%.*]], <4 x float>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <4 x float> @llvm.aarch64.neon.faddp.v4f32(<4 x float> [[A]], <4 x float> [[B]])
@@ -206,7 +206,7 @@ float64x2_t test_vpaddq_f64(float64x2_t a, float64x2_t b) {
 // CIR-LABEL: vpaddq_f64
 // CIR: [[RES:%.*]] = cir.llvm.intrinsic "aarch64.neon.addp" {{%.*}}, {{%.*}} :
 // CIR-SAME: (!cir.vector<!cir.double x 2>, !cir.vector<!cir.double x 2>) -> !cir.vector<!cir.double x 2>
-// CIR: {{%.*}} = cir.cast(bitcast, [[RES]] : !cir.vector<!cir.double x 2>), !cir.vector<!s8i x 16>
+// CIR: {{%.*}} = cir.cast bitcast [[RES]] : !cir.vector<!cir.double x 2> -> !cir.vector<!s8i x 16>
 
 // LLVM: {{.*}}test_vpaddq_f64(<2 x double>{{.*}}[[A:%.*]], <2 x double>{{.*}}[[B:%.*]])
 // LLVM: [[RES:%.*]] = call <2 x double> @llvm.aarch64.neon.faddp.v2f64(<2 x double> [[A]], <2 x double> [[B]])
@@ -759,7 +759,7 @@ int16x4_t test_vabs_s16(int16x4_t a) {
   return vabs_s16(a);
 
   // CIR-LABEL: vabs_s16
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 4>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 4>
   // CIR: cir.abs [[TMP0]] : !cir.vector<!s16i x 4>
 
   // LLVM: {{.*}}test_vabs_s16(<4 x i16>{{.*}}[[a:%.*]])
@@ -771,7 +771,7 @@ int16x8_t test_vabsq_s16(int16x8_t a) {
   return vabsq_s16(a);
 
   // CIR-LABEL: vabsq_s16
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: cir.abs [[TMP0]] : !cir.vector<!s16i x 8>
 
   // LLVM: {{.*}}test_vabsq_s16(<8 x i16>{{.*}}[[a:%.*]])
@@ -783,7 +783,7 @@ int32x2_t test_vabs_s32(int32x2_t a) {
   return vabs_s32(a);
 
   // CIR-LABEL: vabs_s32
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s32i x 2>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s32i x 2>
   // CIR: cir.abs [[TMP0]] : !cir.vector<!s32i x 2>
 
   // LLVM: {{.*}}test_vabs_s32(<2 x i32>{{.*}}[[a:%.*]])
@@ -795,7 +795,7 @@ int32x4_t test_vabsq_s32(int32x4_t a) {
   return vabsq_s32(a);
 
   // CIR-LABEL: vabsq_s32
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: cir.abs [[TMP0]] : !cir.vector<!s32i x 4>
 
   // LLVM: {{.*}}test_vabsq_s32(<4 x i32>{{.*}}[[a:%.*]])
@@ -807,7 +807,7 @@ int64x1_t test_vabs_s64(int64x1_t a) {
   return vabs_s64(a);
 
   // CIR-LABEL: vabs_s64
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
   // CIR: cir.abs [[TMP0]] : !cir.vector<!s64i x 1>
 
   // LLVM: {{.*}}test_vabs_s64(<1 x i64>{{.*}}[[a:%.*]])
@@ -819,7 +819,7 @@ int64x2_t test_vabsq_s64(int64x2_t a) {
   return vabsq_s64(a);
 
   // CIR-LABEL: vabsq_s64
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: cir.abs [[TMP0]] : !cir.vector<!s64i x 2>
 
   // LLVM: {{.*}}test_vabsq_s64(<2 x i64>{{.*}}[[a:%.*]])
@@ -832,7 +832,7 @@ float32x2_t test_vabs_f32(float32x2_t a) {
   return vabs_f32(a);
 
   // CIR-LABEL: vabs_f32
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.float x 2>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.float x 2>
   // CIR: cir.fabs [[TMP0]] : !cir.vector<!cir.float x 2>
 
   // LLVM: {{.*}}test_vabs_f32(<2 x float>{{.*}}[[a:%.*]])
@@ -844,7 +844,7 @@ float32x4_t test_vabsq_f32(float32x4_t a) {
   return vabsq_f32(a);
 
   // CIR-LABEL: vabsq_f32
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.float x 4>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.float x 4>
   // CIR: cir.fabs [[TMP0]] : !cir.vector<!cir.float x 4>
 
   // LLVM: {{.*}}test_vabsq_f32(<4 x float>{{.*}}[[a:%.*]])
@@ -856,7 +856,7 @@ float64x1_t test_vabs_f64(float64x1_t a) {
   return vabs_f64(a);
 
   // CIR-LABEL: vabs_f64
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.double x 1>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.double x 1>
   // CIR: cir.fabs [[TMP0]] : !cir.vector<!cir.double x 1>
 
   // LLVM: {{.*}}test_vabs_f64(<1 x double>{{.*}}[[a:%.*]])
@@ -868,7 +868,7 @@ float64x2_t test_vabsq_f64(float64x2_t a) {
   return vabsq_f64(a);
 
   // CIR-LABEL: vabsq_f64
-  // CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.double x 2>
+  // CIR: [[TMP0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.double x 2>
   // CIR: cir.fabs [[TMP0]] : !cir.vector<!cir.double x 2>
 
   // LLVM: {{.*}}test_vabsq_f64(<2 x double>{{.*}}[[a:%.*]])
@@ -949,7 +949,7 @@ uint16_t test_vaddv_u16(uint16x4_t a) {
 
   // CIR-LABEL: vaddv_u16
   // CIR: [[VADDV_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddv" {{%.*}} : (!cir.vector<!u16i x 4>) -> !s32i
-  // CIR: cir.cast(integral, [[VADDV_I]] : !s32i), !u16i
+  // CIR: cir.cast integral [[VADDV_I]] : !s32i -> !u16i
 
   // LLVM: {{.*}}test_vaddv_u16(<4 x i16>{{.*}}[[A:%.*]])
   // LLVM:    [[VADDV_I:%.*]] = call i32 @llvm.aarch64.neon.uaddv.i32.v4i16(<4 x i16> [[A]])
@@ -962,7 +962,7 @@ int16_t test_vaddv_s16(int16x4_t a) {
 
   // CIR-LABEL: vaddv_s16
   // CIR: [[VADDV_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddv" {{%.*}} : (!cir.vector<!s16i x 4>) -> !s32i
-  // CIR: cir.cast(integral, [[VADDV_I]] : !s32i), !s16i
+  // CIR: cir.cast integral [[VADDV_I]] : !s32i -> !s16i
 
   // LLVM: {{.*}}test_vaddv_s16(<4 x i16>{{.*}}[[A:%.*]])
   // LLVM:    [[VADDV_I:%.*]] = call i32 @llvm.aarch64.neon.saddv.i32.v4i16(<4 x i16> [[A]])
diff --git a/clang/test/CIR/CodeGen/AArch64/neon-ldst.c b/clang/test/CIR/CodeGen/AArch64/neon-ldst.c
index 53e565e2a030..fb694777299d 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon-ldst.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon-ldst.c
@@ -21,7 +21,7 @@ int8x8_t test_vld1_lane_s8(int8_t const * ptr, int8x8_t src) {
 
 // CIR-LABEL: test_vld1_lane_s8
 // CIR: [[IDX:%.*]] = cir.const #cir.int<7> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s8i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s8i>
 // CIR: [[VAL:%.*]] = cir.load align(1) [[PTR]] : !cir.ptr<!s8i>, !s8i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s8i x 8>
 
@@ -36,7 +36,7 @@ int8x16_t test_vld1q_lane_s8(int8_t const * ptr, int8x16_t src) {
 
 // CIR-LABEL: test_vld1q_lane_s8
 // CIR: [[IDX:%.*]] = cir.const #cir.int<15> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s8i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s8i>
 // CIR: [[VAL:%.*]] = cir.load align(1) [[PTR]] : !cir.ptr<!s8i>, !s8i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s8i x 16>
 
@@ -51,7 +51,7 @@ uint8x16_t test_vld1q_lane_u8(uint8_t const * ptr, uint8x16_t src) {
 
 // CIR-LABEL: test_vld1q_lane_u8
 // CIR: [[IDX:%.*]] = cir.const #cir.int<15> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u8i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // CIR: [[VAL:%.*]] = cir.load align(1) [[PTR]] : !cir.ptr<!u8i>, !u8i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u8i x 16>
 
@@ -66,7 +66,7 @@ uint8x8_t test_vld1_lane_u8(uint8_t const * ptr, uint8x8_t src) {
 
 // CIR-LABEL: test_vld1_lane_u8
 // CIR: [[IDX:%.*]] = cir.const #cir.int<7> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u8i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // CIR: [[VAL:%.*]] = cir.load align(1) [[PTR]] : !cir.ptr<!u8i>, !u8i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u8i x 8>
 
@@ -81,7 +81,7 @@ int16x4_t test_vld1_lane_s16(int16_t const * ptr, int16x4_t src) {
 
 // CIR-LABEL: test_vld1_lane_s16
 // CIR: [[IDX:%.*]] = cir.const #cir.int<3> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s16i>
 // CIR: [[VAL:%.*]] = cir.load align(2) [[PTR]] : !cir.ptr<!s16i>, !s16i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s16i x 4>
 
@@ -98,7 +98,7 @@ uint16x4_t test_vld1_lane_u16(uint16_t const * ptr, uint16x4_t src) {
 
 // CIR-LABEL: test_vld1_lane_u16
 // CIR: [[IDX:%.*]] = cir.const #cir.int<3> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u16i>
 // CIR: [[VAL:%.*]] = cir.load align(2) [[PTR]] : !cir.ptr<!u16i>, !u16i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u16i x 4>
 
@@ -115,7 +115,7 @@ int16x8_t test_vld1q_lane_s16(int16_t const * ptr, int16x8_t src) {
 
 // CIR-LABEL: test_vld1q_lane_s16
 // CIR: [[IDX:%.*]] = cir.const #cir.int<7> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s16i>
 // CIR: [[VAL:%.*]] = cir.load align(2) [[PTR]] : !cir.ptr<!s16i>, !s16i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s16i x 8>
 
@@ -132,7 +132,7 @@ uint16x8_t test_vld1q_lane_u16(uint16_t const * ptr, uint16x8_t src) {
 
 // CIR-LABEL: test_vld1q_lane_u16
 // CIR: [[IDX:%.*]] = cir.const #cir.int<7> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u16i>
 // CIR: [[VAL:%.*]] = cir.load align(2) [[PTR]] : !cir.ptr<!u16i>, !u16i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u16i x 8>
 
@@ -149,7 +149,7 @@ int32x2_t test_vld1_lane_s32(int32_t const * ptr, int32x2_t src) {
 
 // CIR-LABEL: test_vld1_lane_s32
 // CIR: [[IDX:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s32i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s32i>
 // CIR: [[VAL:%.*]] = cir.load align(4) [[PTR]] : !cir.ptr<!s32i>, !s32i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s32i x 2>
 
@@ -166,7 +166,7 @@ uint32x2_t test_vld1_lane_u32(uint32_t const * ptr, uint32x2_t src) {
 
 // CIR-LABEL: test_vld1_lane_u32
 // CIR: [[IDX:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u32i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u32i>
 // CIR: [[VAL:%.*]] = cir.load align(4) [[PTR]] : !cir.ptr<!u32i>, !u32i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u32i x 2>
 
@@ -184,7 +184,7 @@ int32x4_t test_vld1q_lane_s32(int32_t const * ptr, int32x4_t src) {
 
 // CIR-LABEL: test_vld1q_lane_s32
 // CIR: [[IDX:%.*]] = cir.const #cir.int<3> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s32i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s32i>
 // CIR: [[VAL:%.*]] = cir.load align(4) [[PTR]] : !cir.ptr<!s32i>, !s32i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s32i x 4>
 
@@ -202,7 +202,7 @@ uint32x4_t test_vld1q_lane_u32(uint32_t const * ptr, uint32x4_t src) {
 
 // CIR-LABEL: test_vld1q_lane_u32
 // CIR: [[IDX:%.*]] = cir.const #cir.int<3> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u32i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u32i>
 // CIR: [[VAL:%.*]] = cir.load align(4) [[PTR]] : !cir.ptr<!u32i>, !u32i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u32i x 4>
 
@@ -219,7 +219,7 @@ int64x1_t test_vld1_lane_s64(int64_t const * ptr, int64x1_t src) {
 
 // CIR-LABEL: test_vld1_lane_s64
 // CIR: [[IDX:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) [[PTR]] : !cir.ptr<!s64i>, !s64i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s64i x 1>
 
@@ -236,7 +236,7 @@ uint64x1_t test_vld1_lane_u64(uint64_t const * ptr, uint64x1_t src) {
 
 // CIR-LABEL: test_vld1_lane_u64
 // CIR: [[IDX:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) [[PTR]] : !cir.ptr<!u64i>, !u64i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u64i x 1>
 
@@ -253,7 +253,7 @@ int64x2_t test_vld1q_lane_s64(int64_t const * ptr, int64x2_t src) {
 
 // CIR-LABEL: test_vld1q_lane_s64
 // CIR: [[IDX:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) [[PTR]] : !cir.ptr<!s64i>, !s64i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!s64i x 2>
 
@@ -270,7 +270,7 @@ uint64x2_t test_vld1q_lane_u64(uint64_t const * ptr, uint64x2_t src) {
 
 // CIR-LABEL: test_vld1q_lane_u64
 // CIR: [[IDX:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) [[PTR]] : !cir.ptr<!u64i>, !u64i
 // CIR: {{%.*}} = cir.vec.insert [[VAL]], {{%.*}}[[[IDX]] : !s32i] : !cir.vector<!u64i x 2>
 
@@ -288,7 +288,7 @@ void test_vst1_lane_s8(int8_t * ptr, int8x8_t src) {
 // CIR-LABEL: test_vst1_lane_s8
 // CIR: [[LANE:%.*]] = cir.const #cir.int<7> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s8i x 8>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s8i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s8i>
 // CIR: cir.store align(1) [[VAL]], [[PTR]] : !s8i, !cir.ptr<!s8i>
 
 // LLVM: {{.*}}test_vst1_lane_s8(ptr{{.*}}[[PTR:%.*]], <8 x i8>{{.*}}[[SRC:%.*]])
@@ -302,7 +302,7 @@ void test_vst1_lane_s16(int16_t * ptr, int16x4_t src) {
 // CIR-LABEL: test_vst1_lane_s16
 // CIR: [[LANE:%.*]] = cir.const #cir.int<3> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s16i x 4>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s16i>
 // CIR: cir.store align(2) [[VAL]], [[PTR]] : !s16i, !cir.ptr<!s16i>
 
 // LLVM: {{.*}}test_vst1_lane_s16(ptr{{.*}}[[PTR:%.*]], <4 x i16>{{.*}}[[SRC:%.*]])
@@ -318,7 +318,7 @@ void test_vst1_lane_u16(uint16_t * ptr, uint16x4_t src) {
 // CIR-LABEL: test_vst1_lane_u16
 // CIR: [[LANE:%.*]] = cir.const #cir.int<3> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!u16i x 4>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u16i>
 // CIR: cir.store align(2) [[VAL]], [[PTR]] : !u16i, !cir.ptr<!u16i>
 
 // LLVM: {{.*}}test_vst1_lane_u16(ptr{{.*}}[[PTR:%.*]], <4 x i16>{{.*}}[[SRC:%.*]])
@@ -334,7 +334,7 @@ void test_vst1_lane_s32(int32_t * ptr, int32x2_t src) {
 // CIR-LABEL: test_vst1_lane_s32
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s32i x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s32i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s32i>
 // CIR: cir.store align(4) [[VAL]], [[PTR]] : !s32i, !cir.ptr<!s32i>
 
 // LLVM: {{.*}}test_vst1_lane_s32(ptr{{.*}}[[PTR:%.*]], <2 x i32>{{.*}}[[SRC:%.*]])
@@ -350,7 +350,7 @@ void test_vst1_lane_f32(float32_t * ptr, float32x2_t src) {
 // CIR-LABEL: test_vst1_lane_f32
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.float x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.float>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.float>
 // CIR: cir.store align(4) [[VAL]], [[PTR]] : !cir.float, !cir.ptr<!cir.float>
 
 // LLVM: {{.*}}test_vst1_lane_f32(ptr{{.*}}[[PTR:%.*]], <2 x float>{{.*}}[[SRC:%.*]])
@@ -366,7 +366,7 @@ void test_vst1_lane_s64(int64_t * ptr, int64x1_t src) {
 // CIR-LABEL: test_vst1_lane_s64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 1>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: cir.store align(8) [[VAL]], [[PTR]] : !s64i, !cir.ptr<!s64i>
 
 // LLVM: {{.*}}test_vst1_lane_s64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
@@ -382,7 +382,7 @@ void test_vst1_lane_f64(float64_t * ptr, float64x1_t src) {
 // CIR-LABEL: test_vst1_lane_f64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.double x 1>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CIR: cir.store align(8) [[VAL]], [[PTR]] : !cir.double, !cir.ptr<!cir.double>
 
 // LLVM: {{.*}}test_vst1_lane_f64(ptr{{.*}}[[PTR:%.*]], <1 x double>{{.*}}[[SRC:%.*]])
@@ -398,7 +398,7 @@ void test_vst1q_lane_s8(int8_t * ptr, int8x16_t src) {
 // CIR-LABEL: test_vst1q_lane_s8
 // CIR: [[LANE:%.*]] = cir.const #cir.int<15> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s8i x 16>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s8i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s8i>
 // CIR: cir.store align(1) [[VAL]], [[PTR]] : !s8i, !cir.ptr<!s8i>
 
 // LLVM: {{.*}}test_vst1q_lane_s8(ptr{{.*}}[[PTR:%.*]], <16 x i8>{{.*}}[[SRC:%.*]])
@@ -413,7 +413,7 @@ void test_vst1q_lane_s16(int16_t * ptr, int16x8_t src) {
 // CIR-LABEL: test_vst1q_lane_s16
 // CIR: [[LANE:%.*]] = cir.const #cir.int<7> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s16i x 8>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s16i>
 // CIR: cir.store align(2) [[VAL]], [[PTR]] : !s16i, !cir.ptr<!s16i>
 
 // LLVM: {{.*}}test_vst1q_lane_s16(ptr{{.*}}[[PTR:%.*]], <8 x i16>{{.*}}[[SRC:%.*]])
@@ -429,7 +429,7 @@ void test_vst1q_lane_u16(uint16_t * ptr, uint16x8_t src) {
 // CIR-LABEL: test_vst1q_lane_u16
 // CIR: [[LANE:%.*]] = cir.const #cir.int<7> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!u16i x 8>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u16i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u16i>
 // CIR: cir.store align(2) [[VAL]], [[PTR]] : !u16i, !cir.ptr<!u16i>
 
 // LLVM: {{.*}}test_vst1q_lane_u16(ptr{{.*}}[[PTR:%.*]], <8 x i16>{{.*}}[[SRC:%.*]])
@@ -445,7 +445,7 @@ void test_vst1q_lane_s32(int32_t * ptr, int32x4_t src) {
 // CIR-LABEL: test_vst1q_lane_s32
 // CIR: [[LANE:%.*]] = cir.const #cir.int<3> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s32i x 4>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s32i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s32i>
 // CIR: cir.store align(4) [[VAL]], [[PTR]] : !s32i, !cir.ptr<!s32i>
 
 // LLVM: {{.*}}test_vst1q_lane_s32(ptr{{.*}}[[PTR:%.*]], <4 x i32>{{.*}}[[SRC:%.*]])
@@ -461,7 +461,7 @@ void test_vst1q_lane_s64(int64_t * ptr, int64x2_t src) {
 // CIR-LABEL: test_vst1q_lane_s64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: cir.store align(8) [[VAL]], [[PTR]] : !s64i, !cir.ptr<!s64i>
 
 // LLVM: {{.*}}test_vst1q_lane_s64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -477,7 +477,7 @@ void test_vst1q_lane_f32(float32_t * ptr, float32x4_t src) {
 // CIR-LABEL: test_vst1q_lane_f32
 // CIR: [[LANE:%.*]] = cir.const #cir.int<3> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.float x 4>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.float>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.float>
 // CIR: cir.store align(4) [[VAL]], [[PTR]] : !cir.float, !cir.ptr<!cir.float>
 
 // LLVM: {{.*}}test_vst1q_lane_f32(ptr{{.*}}[[PTR:%.*]], <4 x float>{{.*}}[[SRC:%.*]])
@@ -493,7 +493,7 @@ void test_vst1q_lane_f64(float64_t * ptr, float64x2_t src) {
 // CIR-LABEL: test_vst1q_lane_f64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.double x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CIR: cir.store align(8) [[VAL]], [[PTR]] : !cir.double, !cir.ptr<!cir.double>
 
 // LLVM: {{.*}}test_vst1q_lane_f64(ptr{{.*}}[[PTR:%.*]], <2 x double>{{.*}}[[SRC:%.*]])
@@ -509,7 +509,7 @@ void test_vstl1q_lane_u64(uint64_t  *a, uint64x2_t b) {
 // CIR-LABEL: test_vstl1q_lane_u64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!u64i x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !u64i, !cir.ptr<!u64i>
 
 // LLVM: {{.*}}test_vstl1q_lane_u64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -525,7 +525,7 @@ void test_vstl1q_lane_s64(int64_t  *a, int64x2_t b) {
 // CIR-LABEL: test_vstl1q_lane_s64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !s64i, !cir.ptr<!s64i>
 
 // LLVM: {{.*}}test_vstl1q_lane_s64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -541,7 +541,7 @@ void test_vstl1q_lane_f64(float64_t  *a, float64x2_t b) {
 // CIR-LABEL: test_vstl1q_lane_f64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.double x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !cir.double, !cir.ptr<!cir.double>
 
 // LLVM: {{.*}}test_vstl1q_lane_f64(ptr{{.*}}[[PTR:%.*]], <2 x double>{{.*}}[[SRC:%.*]])
@@ -557,7 +557,7 @@ void test_vstl1q_lane_p64(poly64_t  *a, poly64x2_t b) {
 // CIR-LABEL: test_vstl1q_lane_p64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 2>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !s64i, !cir.ptr<!s64i>
 
 // LLVM: {{.*}}test_vstl1q_lane_p64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -573,7 +573,7 @@ void test_vstl1_lane_u64(uint64_t  *a, uint64x1_t b) {
 // CIR-LABEL: test_vstl1_lane_u64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!u64i x 1>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !u64i, !cir.ptr<!u64i>
 
 // LLVM: {{.*}}test_vstl1_lane_u64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
@@ -589,7 +589,7 @@ void test_vstl1_lane_s64(int64_t  *a, int64x1_t b) {
 // CIR-LABEL:test_vstl1_lane_s64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 1>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !s64i, !cir.ptr<!s64i>
 
 // LLVM: {{.*}}test_vstl1_lane_s64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
@@ -605,7 +605,7 @@ void test_vstl1_lane_f64(float64_t  *a, float64x1_t b) {
 // CIR-LABEL:test_vstl1_lane_f64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.double x 1>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !cir.double, !cir.ptr<!cir.double>
 
 // LLVM: {{.*}}test_vstl1_lane_f64(ptr{{.*}}[[PTR:%.*]], <1 x double>{{.*}}[[SRC:%.*]])
@@ -621,7 +621,7 @@ void test_vstl1_lane_p64(poly64_t  *a, poly64x1_t b) {
 // CIR-LABEL: test_vstl1_lane_p64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
 // CIR: [[VAL:%.*]] = cir.vec.extract {{%.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 1>
-// CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: cir.store align(8) atomic(release) [[VAL]], [[PTR]] : !s64i, !cir.ptr<!s64i>
 
 // LLVM: {{.*}}test_vstl1_lane_p64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
@@ -636,9 +636,9 @@ uint64x2_t test_vldap1q_lane_u64(uint64_t  *a, uint64x2_t b) {
 
 // CIR-LABEL:test_vldap1q_lane_u64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!u64i>, !u64
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!u64i x 2>
 
 // LLVM: {{.*}}test_vldap1q_lane_u64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -653,9 +653,9 @@ int64x2_t test_vldap1q_lane_s64(int64_t  *a, int64x2_t b) {
 
 // CIR-LABEL:test_vldap1q_lane_s64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!s64i>, !s64
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 2>
 
 // LLVM: {{.*}}test_vldap1q_lane_s64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -670,9 +670,9 @@ float64x2_t test_vldap1q_lane_f64(float64_t  *a, float64x2_t b) {
 
 // CIR-LABEL:test_vldap1q_lane_f64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!cir.double>, !cir.double
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.double x 2>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.double x 2>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.double x 2>
 
 // LLVM: {{.*}}test_vldap1q_lane_f64(ptr{{.*}}[[PTR:%.*]], <2 x double>{{.*}}[[SRC:%.*]])
@@ -687,9 +687,9 @@ poly64x2_t test_vldap1q_lane_p64(poly64_t  *a, poly64x2_t b) {
 
 // CIR-LABEL:test_vldap1q_lane_p64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!s64i>, !s64
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 2>
 
 // LLVM: {{.*}}test_vldap1q_lane_p64(ptr{{.*}}[[PTR:%.*]], <2 x i64>{{.*}}[[SRC:%.*]])
@@ -704,9 +704,9 @@ uint64x1_t test_vldap1_lane_u64(uint64_t  *a, uint64x1_t b) {
 
 // CIR-LABEL:test_vldap1_lane_u64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!u64i>, !u64
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!u64i x 1>
 
 // LLVM: {{.*}}test_vldap1_lane_u64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
@@ -721,9 +721,9 @@ int64x1_t test_vldap1_lane_s64(int64_t  *a, int64x1_t b) {
 
 // CIR-LABEL:test_vldap1_lane_s64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!s64i>, !s64
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 1>
 
 // LLVM: {{.*}}test_vldap1_lane_s64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
@@ -739,9 +739,9 @@ float64x1_t test_vldap1_lane_f64(float64_t  *a, float64x1_t b) {
 
 // CIR-LABEL: test_vldap1_lane_f64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!cir.double>, !cir.double
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.double x 1>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.double x 1>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!cir.double x 1>
 
 // LLVM: {{.*}}test_vldap1_lane_f64(ptr{{.*}}[[PTR:%.*]], <1 x double>{{.*}}[[SRC:%.*]])
@@ -756,9 +756,9 @@ poly64x1_t test_vldap1_lane_p64(poly64_t  *a, poly64x1_t b) {
 
 // CIR-LABEL: test_vldap1_lane_p64
 // CIR: [[LANE:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!s64i>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!s64i>
 // CIR: [[VAL:%.*]] = cir.load align(8) atomic(acquire) [[TMP0]] : !cir.ptr<!s64i>, !s64
-// CIR: [[VEC:%.*]] = cir.cast(bitcast, {{.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+// CIR: [[VEC:%.*]] = cir.cast bitcast {{.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
 // CIR: [[TMP:%.*]]  = cir.vec.insert [[VAL]], {{.*}}[[[LANE]] : !s32i] : !cir.vector<!s64i x 1>
 
 // LLVM: {{.*}}test_vldap1_lane_p64(ptr{{.*}}[[PTR:%.*]], <1 x i64>{{.*}}[[SRC:%.*]])
diff --git a/clang/test/CIR/CodeGen/AArch64/neon-misc.c b/clang/test/CIR/CodeGen/AArch64/neon-misc.c
index ee2caebb840a..814287cff37f 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon-misc.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon-misc.c
@@ -309,7 +309,7 @@ uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) {
   return vtrn_u8(a, b);
 
   // CIR-LABEL: vtrn_u8
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 8>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 8>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u8i x 8>>, !s32i) -> !cir.ptr<!cir.vector<!u8i x 8>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u8i x 8>) 
@@ -339,7 +339,7 @@ uint16x4x2_t test_vtrn_u16(uint16x4_t a, uint16x4_t b) {
   return vtrn_u16(a, b);
 
   // CIR-LABEL: vtrn_u16
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u16i x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u16i x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u16i x 4>>, !s32i) -> !cir.ptr<!cir.vector<!u16i x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u16i x 4>) 
@@ -365,7 +365,7 @@ int32x2x2_t test_vtrn_s32(int32x2_t a, int32x2_t b) {
   return vtrn_s32(a, b);
 
   // CIR-LABEL: vtrn_s32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s32i x 2>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s32i x 2>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!s32i x 2>>, !s32i) -> !cir.ptr<!cir.vector<!s32i x 2>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!s32i x 2>) 
@@ -391,7 +391,7 @@ uint8x16x2_t test_vtrnq_u8(uint8x16_t a, uint8x16_t b) {
   return vtrnq_u8(a, b);
 
   // CIR-LABEL: vtrnq_u8
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 16>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u8i x 16>>, !s32i) -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u8i x 16>) 
@@ -426,7 +426,7 @@ int16x8x2_t test_vtrnq_s16(int16x8_t a, int16x8_t b) {
   return vtrnq_s16(a, b);
 
   // CIR-LABEL: vtrnq_s16
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s16i x 8>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!s16i x 8>>, !s32i) -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!s16i x 8>) 
@@ -455,7 +455,7 @@ uint32x4x2_t test_vtrnq_u32(uint32x4_t a, uint32x4_t b) {
   return vtrnq_u32(a, b);
 
   // CIR-LABEL: vtrnq_u32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u32i x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u32i x 4>>, !s32i) -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u32i x 4>) 
@@ -475,7 +475,7 @@ uint8x8x2_t test_vuzp_u8(uint8x8_t a, uint8x8_t b) {
   return vuzp_u8(a, b);
 
   // CIR-LABEL:vuzp_u8
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 8>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 8>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u8i x 8>>, !s32i) -> !cir.ptr<!cir.vector<!u8i x 8>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u8i x 8>)
@@ -506,7 +506,7 @@ uint16x4x2_t test_vuzp_u16(uint16x4_t a, uint16x4_t b) {
   return vuzp_u16(a, b);
 
   // CIR-LABEL: vuzp_u16
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u16i x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u16i x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u16i x 4>>, !s32i) -> !cir.ptr<!cir.vector<!u16i x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u16i x 4>)
@@ -533,7 +533,7 @@ int32x2x2_t test_vuzp_s32(int32x2_t a, int32x2_t b) {
   return vuzp_s32(a, b);
 
   // CIR-LABEL: vuzp_s32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s32i x 2>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s32i x 2>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!s32i x 2>>, !s32i) -> !cir.ptr<!cir.vector<!s32i x 2>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!s32i x 2>)
@@ -560,7 +560,7 @@ float32x2x2_t test_vuzp_f32(float32x2_t a, float32x2_t b) {
   return vuzp_f32(a, b);
 
   // CIR-LABEL: vuzp_f32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!cir.float x 2>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!cir.float x 2>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!cir.float x 2>>, !s32i) -> !cir.ptr<!cir.vector<!cir.float x 2>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!cir.float x 2>)
@@ -587,7 +587,7 @@ uint8x16x2_t test_vuzpq_u8(uint8x16_t a, uint8x16_t b) {
   return vuzpq_u8(a, b);
 
   // CIR-LABEL: vuzpq_u8
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 16>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u8i x 16>>, !s32i) -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u8i x 16>)
@@ -621,7 +621,7 @@ int16x8x2_t test_vuzpq_s16(int16x8_t a, int16x8_t b) {
   return vuzpq_s16(a, b);
 
   // CIR-LABEL: vuzpq_s16
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s16i x 8>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!s16i x 8>>, !s32i) -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!s16i x 8>)
@@ -651,7 +651,7 @@ uint32x4x2_t test_vuzpq_u32(uint32x4_t a, uint32x4_t b) {
   return vuzpq_u32(a, b);
 
   // CIR-LABEL: vuzpq_u32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u32i x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u32i x 4>>, !s32i) -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u32i x 4>)
@@ -672,7 +672,7 @@ float32x4x2_t test_vuzpq_f32(float32x4_t a, float32x4_t b) {
   return vuzpq_f32(a, b);
 
   // CIR-LABEL: vuzpq_f32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!cir.float x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!cir.float x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!cir.float x 4>>, !s32i) -> !cir.ptr<!cir.vector<!cir.float x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!cir.float x 4>)
@@ -693,7 +693,7 @@ uint8x8x2_t test_vzip_u8(uint8x8_t a, uint8x8_t b) {
   return vzip_u8(a, b);
 
   // CIR-LABEL:vzip_u8
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 8>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 8>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u8i x 8>>, !s32i) -> !cir.ptr<!cir.vector<!u8i x 8>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u8i x 8>)
@@ -723,7 +723,7 @@ uint16x4x2_t test_vzip_u16(uint16x4_t a, uint16x4_t b) {
   return vzip_u16(a, b);
 
   // CIR-LABEL: vzip_u16
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u16i x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u16i x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u16i x 4>>, !s32i) -> !cir.ptr<!cir.vector<!u16i x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u16i x 4>)
@@ -750,7 +750,7 @@ int32x2x2_t test_vzip_s32(int32x2_t a, int32x2_t b) {
   return vzip_s32(a, b);
 
   // CIR-LABEL: vzip_s32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s32i x 2>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s32i x 2>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!s32i x 2>>, !s32i) -> !cir.ptr<!cir.vector<!s32i x 2>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!s32i x 2>)
@@ -777,7 +777,7 @@ float32x2x2_t test_vzip_f32(float32x2_t a, float32x2_t b) {
   return vzip_f32(a, b);
 
   // CIR-LABEL: vzip_f32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!cir.float x 2>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!cir.float x 2>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!cir.float x 2>>, !s32i) -> !cir.ptr<!cir.vector<!cir.float x 2>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!cir.float x 2>)
@@ -804,7 +804,7 @@ uint8x16x2_t test_vzipq_u8(uint8x16_t a, uint8x16_t b) {
   return vzipq_u8(a, b);
 
   // CIR-LABEL: vzipq_u8
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 16>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u8i x 16>>, !s32i) -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u8i x 16>)
@@ -838,7 +838,7 @@ int16x8x2_t test_vzipq_s16(int16x8_t a, int16x8_t b) {
   return vzipq_s16(a, b);
 
   // CIR-LABEL: vzipq_s16
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s16i x 8>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!s16i x 8>>, !s32i) -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!s16i x 8>)
@@ -868,7 +868,7 @@ uint32x4x2_t test_vzipq_u32(uint32x4_t a, uint32x4_t b) {
   return vzipq_u32(a, b);
 
   // CIR-LABEL: vzipq_u32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u32i x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!u32i x 4>>, !s32i) -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!u32i x 4>)
@@ -889,7 +889,7 @@ float32x4x2_t test_vzipq_f32(float32x4_t a, float32x4_t b) {
   return vzipq_f32(a, b);
 
   // CIR-LABEL: vzipq_f32
-  // CIR: [[PTR:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!cir.float x 4>>
+  // CIR: [[PTR:%.*]] = cir.cast bitcast {{%.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!cir.float x 4>>
   // CIR: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
   // CIR: [[ADDR:%.*]] = cir.ptr_stride [[PTR]], [[ZERO]] : (!cir.ptr<!cir.vector<!cir.float x 4>>, !s32i) -> !cir.ptr<!cir.vector<!cir.float x 4>>
   // CIR: [[RES:%.*]] = cir.vec.shuffle([[INP1:%.*]], [[INP2:%.*]] : !cir.vector<!cir.float x 4>)
@@ -946,8 +946,8 @@ uint8x8_t test_vtst_s8(int8x8_t v1, int8x8_t v2) {
   return vtst_s8(v1, v2);
 
   // CIR-LABEL: vtst_s8
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u8i x 8> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u8i x 8>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u8i x 8> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u8i x 8>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u8i x 8>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u8i x 8>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u8i x 8>, !cir.vector<!u8i x 8>
@@ -963,8 +963,8 @@ uint8x8_t test_vtst_u8(uint8x8_t v1, uint8x8_t v2) {
   return vtst_u8(v1, v2);
 
   // CIR-LABEL: vtst_u8
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u8i x 8> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u8i x 8>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u8i x 8> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u8i x 8>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u8i x 8>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u8i x 8>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u8i x 8>, !cir.vector<!u8i x 8>
@@ -980,8 +980,8 @@ uint16x4_t test_vtst_s16(int16x4_t v1, int16x4_t v2) {
   return vtst_s16(v1, v2);
 
   // CIR-LABEL: vtst_s16
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u16i x 4>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u16i x 4>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u16i x 4>, !cir.vector<!u16i x 4>
@@ -996,8 +996,8 @@ uint16x4_t test_vtst_u16(uint16x4_t v1, uint16x4_t v2) {
   return vtst_u16(v1, v2);
 
   // CIR-LABEL: vtst_u16
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u16i x 4>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u16i x 4>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u16i x 4>, !cir.vector<!u16i x 4>
@@ -1012,8 +1012,8 @@ uint32x2_t test_vtst_s32(int32x2_t v1, int32x2_t v2) {
   return vtst_s32(v1, v2);
 
   // CIR-LABEL: vtst_s32
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u32i x 2>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u32i x 2>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u32i x 2>, !cir.vector<!u32i x 2>
@@ -1028,8 +1028,8 @@ uint32x2_t test_vtst_u32(uint32x2_t v1, uint32x2_t v2) {
   return vtst_u32(v1, v2);
 
   // CIR-LABEL: vtst_u32
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u32i x 2>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u32i x 2>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u32i x 2>, !cir.vector<!u32i x 2>
@@ -1044,8 +1044,8 @@ uint64x1_t test_vtst_s64(int64x1_t a, int64x1_t b) {
   return vtst_s64(a, b);
 
   // CIR-LABEL: vtst_s64
-  // CIR: [[A:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1> 
-  // CIR: [[B:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[A:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1> 
+  // CIR: [[B:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: [[AND:%.*]] = cir.binop(and, [[A]], [[B]]) : !cir.vector<!u64i x 1>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u64i x 1>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u64i x 1>, !cir.vector<!u64i x 1>
@@ -1060,8 +1060,8 @@ uint64x1_t test_vtst_u64(uint64x1_t a, uint64x1_t b) {
   return vtst_u64(a, b);
 
   // CIR-LABEL: vtst_u64
-  // CIR: [[A:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1> 
-  // CIR: [[B:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[A:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1> 
+  // CIR: [[B:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: [[AND:%.*]] = cir.binop(and, [[A]], [[B]]) : !cir.vector<!u64i x 1>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u64i x 1>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u64i x 1>, !cir.vector<!u64i x 1>
@@ -1076,8 +1076,8 @@ uint8x16_t test_vtstq_s8(int8x16_t v1, int8x16_t v2) {
   return vtstq_s8(v1, v2);
 
   // CIR-LABEL: vtstq_s8
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u8i x 16> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u8i x 16>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u8i x 16> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u8i x 16>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u8i x 16>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u8i x 16>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u8i x 16>, !cir.vector<!u8i x 16>
@@ -1092,8 +1092,8 @@ uint8x16_t test_vtstq_u8(uint8x16_t v1, uint8x16_t v2) {
   return vtstq_u8(v1, v2);
 
   // CIR-LABEL: vtstq_u8
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u8i x 16> 
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u8i x 16>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u8i x 16> 
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u8i x 16>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]]) : !cir.vector<!u8i x 16>
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u8i x 16>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u8i x 16>, !cir.vector<!u8i x 16>
@@ -1108,8 +1108,8 @@ uint16x8_t test_vtstq_s16(int16x8_t v1, int16x8_t v2) {
   return vtstq_s16(v1, v2);
 
   // CIR-LABEL: vtstq_s16
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]])
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u16i x 8>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u16i x 8>, !cir.vector<!u16i x 8>
@@ -1124,8 +1124,8 @@ uint16x8_t test_vtstq_u16(uint16x8_t v1, uint16x8_t v2) {
   return vtstq_u16(v1, v2);
 
   // CIR-LABEL: vtstq_u16
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]])
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u16i x 8>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u16i x 8>, !cir.vector<!u16i x 8>
@@ -1140,8 +1140,8 @@ uint32x4_t test_vtstq_s32(int32x4_t v1, int32x4_t v2) {
   return vtstq_s32(v1, v2);
 
   // CIR-LABEL: vtstq_s32
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]])
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u32i x 4>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u32i x 4>, !cir.vector<!u32i x 4>
@@ -1156,8 +1156,8 @@ uint32x4_t test_vtstq_u32(uint32x4_t v1, uint32x4_t v2) {
   return vtstq_u32(v1, v2);
 
   // CIR-LABEL: vtstq_u32
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]])
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u32i x 4>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u32i x 4>, !cir.vector<!u32i x 4>
@@ -1172,8 +1172,8 @@ uint64x2_t test_vtstq_s64(int64x2_t v1, int64x2_t v2) {
   return vtstq_s64(v1, v2);
 
   // CIR-LABEL: vtstq_s64
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]])
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u64i x 2>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u64i x 2>, !cir.vector<!u64i x 2>
@@ -1188,8 +1188,8 @@ uint64x2_t test_vtstq_u64(uint64x2_t v1, uint64x2_t v2) {
   return vtstq_u64(v1, v2);
 
   // CIR-LABEL: vtstq_u64
-  // CIR: [[V1:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
-  // CIR: [[V2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[V1:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
+  // CIR: [[V2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[AND:%.*]] = cir.binop(and, [[V1]], [[V2]])
   // CIR: [[ZERO_VEC:%.*]] = cir.const #cir.zero : !cir.vector<!u64i x 2>
   // CIR: {{%.*}} = cir.vec.cmp(ne, [[AND]], [[ZERO_VEC]]) : !cir.vector<!u64i x 2>, !cir.vector<!u64i x 2>
@@ -1264,7 +1264,7 @@ float32x2_t test_vcvt_f32_s32(int32x2_t a) {
   return vcvt_f32_s32(a);
 
   // CIR-LABEL: vcvt_f32_s32
-  // {{%.*}} = cir.cast(int_to_float, {{%.*}} : !cir.vector<!s32i x 2>), !cir.vector<!cir.float x 2>
+  // {{%.*}} = cir.cast int_to_float {{%.*}} : !cir.vector<!s32i x 2> -> !cir.vector<!cir.float x 2>
 
   // LLVM: {{.*}}test_vcvt_f32_s32(<2 x i32>{{.*}}[[a:%.*]])
   // LLVM:  [[VCVT_I:%.*]] = sitofp <2 x i32> {{.*}} to <2 x float>
@@ -1274,7 +1274,7 @@ float32x2_t test_vcvt_f32_u32(uint32x2_t a) {
   return vcvt_f32_u32(a);
 
   // CIR-LABEL: vcvt_f32_u32
-  // {{%.*}} = cir.cast(int_to_float, {{%.*}} : !cir.vector<!u32i x 2>), !cir.vector<!cir.float x 2>
+  // {{%.*}} = cir.cast int_to_float {{%.*}} : !cir.vector<!u32i x 2> -> !cir.vector<!cir.float x 2>
 
   // LLVM: {{.*}}test_vcvt_f32_u32(<2 x i32>{{.*}}[[a:%.*]])
   // LLVM:  [[VCVT_I:%.*]] = uitofp <2 x i32> {{.*}} to <2 x float>
@@ -1284,7 +1284,7 @@ float32x4_t test_vcvtq_f32_s32(int32x4_t a) {
   return vcvtq_f32_s32(a);
 
   // CIR-LABEL: vcvtq_f32_s32
-  // {{%.*}} = cir.cast(int_to_float, {{%.*}} : !cir.vector<!s32i x 4>), !cir.vector<!cir.float x 4>
+  // {{%.*}} = cir.cast int_to_float {{%.*}} : !cir.vector<!s32i x 4> -> !cir.vector<!cir.float x 4>
 
   // LLVM: {{.*}}test_vcvtq_f32_s32(<4 x i32>{{.*}}[[a:%.*]])
   // LLVM:  [[VCVT_I:%.*]] = sitofp <4 x i32> {{.*}} to <4 x float>
@@ -1294,7 +1294,7 @@ float32x4_t test_vcvtq_f32_u32(uint32x4_t a) {
   return vcvtq_f32_u32(a);
 
   // CIR-LABEL: vcvtq_f32_u32
-  // {{%.*}} = cir.cast(int_to_float, {{%.*}} : !cir.vector<!u32i x 4>), !cir.vector<!cir.float x 4>
+  // {{%.*}} = cir.cast int_to_float {{%.*}} : !cir.vector<!u32i x 4> -> !cir.vector<!cir.float x 4>
 
   // LLVM: {{.*}}test_vcvtq_f32_u32(<4 x i32>{{.*}}[[a:%.*]])
   // LLVM:  [[VCVT_I:%.*]] = uitofp <4 x i32> {{.*}} to <4 x float>
@@ -1319,7 +1319,7 @@ int16x4_t test_splat_lane_s16(int16x4_t v) {
   return (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)v, 3, 1);
 
   // CIR-LABEL: test_splat_lane_s16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s16i x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s16i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s16i x 4>
@@ -1335,7 +1335,7 @@ int32x2_t test_splat_lane_s32(int32x2_t v) {
   return (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)v, 1, 2);
 
   // CIR-LABEL: test_splat_lane_s32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s32i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s32i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s32i x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s32i x 2>) 
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!s32i x 2>
@@ -1351,7 +1351,7 @@ int64x1_t test_splat_lane_s64(int64x1_t v) {
   return (int64x1_t) __builtin_neon_splat_lane_v((int8x8_t)v, 0, 3);
 
   // CIR-LABEL: test_splat_lane_s64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s64i x 1>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s64i x 1>) [#cir.int<0> : !s32i] : !cir.vector<!s64i x 1>
 
@@ -1366,7 +1366,7 @@ uint8x8_t test_splat_lane_u8(uint8x8_t v) {
   return (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)v, 7, 16);
 
   // CIR-LABEL: test_splat_lane_u8
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u8i x 8>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u8i x 8>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u8i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u8i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i,
@@ -1380,7 +1380,7 @@ uint16x4_t test_splat_lane_u16(uint16x4_t v) {
   return (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)v, 3, 17);
 
   // CIR-LABEL: test_splat_lane_u16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u16i x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u16i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!u16i x 4>
@@ -1396,7 +1396,7 @@ uint32x2_t test_splat_lane_u32(uint32x2_t v) {
   return (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)v, 1, 18);
 
   // CIR-LABEL: test_splat_lane_u32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u32i x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u32i x 2>)
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!u32i x 2>
@@ -1412,7 +1412,7 @@ uint64x1_t test_splat_lane_u64(uint64x1_t v) {
   return (uint64x1_t) __builtin_neon_splat_lane_v((int8x8_t)v, 0, 19);
 
   // CIR-LABEL: test_splat_lane_u64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u64i x 1>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u64i x 1>) [#cir.int<0> : !s32i] : !cir.vector<!u64i x 1>
 
@@ -1427,7 +1427,7 @@ float32x2_t test_splat_lane_f32(float32x2_t v) {
   return (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)v, 1, 9);
 
   // CIR-LABEL: test_splat_lane_f32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.float x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.float x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.float x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.float x 2>) 
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!cir.float x 2>
@@ -1443,7 +1443,7 @@ float64x1_t test_splat_lane_f64(float64x1_t v) {
   return (float64x1_t) __builtin_neon_splat_lane_v((int8x8_t)v, 0, 10);
 
   // CIR-LABEL: test_splat_lane_f64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.double x 1>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.double x 1>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.double x 1>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.double x 1>) [#cir.int<0> : !s32i] : !cir.vector<!cir.double x 1>
 
@@ -1476,7 +1476,7 @@ int16x8_t test_splatq_lane_s16(int16x4_t v) {
   return (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 3, 1);
 
   // CIR-LABEL: test_splatq_lane_s16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s16i x 4>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s16i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i,
@@ -1493,7 +1493,7 @@ int32x4_t test_splatq_lane_s32(int32x2_t v) {
   return (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 1, 2);
 
   // CIR-LABEL: test_splatq_lane_s32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s32i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s32i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s32i x 2>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s32i x 2>)
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!s32i x 4>
@@ -1509,7 +1509,7 @@ int64x2_t test_splatq_lane_s64(int64x1_t v) {
   return (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 0, 3);
 
   // CIR-LABEL: test_splatq_lane_s64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s64i x 1>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s64i x 1>)
   // CIR-SAME: [#cir.int<0> : !s32i, #cir.int<0> : !s32i] : !cir.vector<!s64i x 2>
@@ -1525,7 +1525,7 @@ uint8x16_t test_splatq_lane_u8(uint8x8_t v) {
   return (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 7, 16);
 
   // CIR-LABEL: test_splatq_lane_u8
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u8i x 8>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u8i x 8>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u8i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u8i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i,
@@ -1543,7 +1543,7 @@ uint16x8_t test_splatq_lane_u16(uint16x4_t v) {
   return (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 3, 17);
 
   // CIR-LABEL: test_splatq_lane_u16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u16i x 4>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u16i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i,
@@ -1560,7 +1560,7 @@ uint32x4_t test_splatq_lane_u32(uint32x2_t v) {
   return (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 1, 18);
 
   // CIR-LABEL: test_splatq_lane_u32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u32i x 2>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u32i x 2>)
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!u32i x 4>
@@ -1576,7 +1576,7 @@ uint64x2_t test_splatq_lane_u64(uint64x1_t v) {
   return (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 0, 19);
 
   // CIR-LABEL: test_splatq_lane_u64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u64i x 1>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u64i x 1>)
   // CIR-SAME: [#cir.int<0> : !s32i, #cir.int<0> : !s32i] : !cir.vector<!u64i x 2>
@@ -1592,7 +1592,7 @@ float32x4_t test_splatq_lane_f32(float32x2_t v) {
   return (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 1, 9);
 
   // CIR-LABEL: test_splatq_lane_f32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.float x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.float x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.float x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.float x 2>)
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!cir.float x 4>
@@ -1608,7 +1608,7 @@ float64x2_t test_splatq_lane_f64(float64x1_t v) {
   return (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)v, 0, 10);
 
   // CIR-LABEL: test_splatq_lane_f64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!cir.double x 1>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!cir.double x 1>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.double x 1>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.double x 1>)
   // CIR-SAME: [#cir.int<0> : !s32i, #cir.int<0> : !s32i] : !cir.vector<!cir.double x 2>
@@ -1640,7 +1640,7 @@ int16x4_t test_splat_laneq_s16(int16x8_t v) {
   return (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 7, 33);
 
   // CIR-LABEL: test_splat_laneq_s16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s16i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s16i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i] : !cir.vector<!s16i x 4>
@@ -1656,7 +1656,7 @@ int32x2_t test_splat_laneq_s32(int32x4_t v) {
   return (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 3, 34);
 
   // CIR-LABEL: test_splat_laneq_s32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s32i x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s32i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s32i x 2>
@@ -1672,7 +1672,7 @@ int64x1_t test_splat_laneq_s64(int64x2_t v) {
   return (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 0, 35);
 
   // CIR-LABEL: test_splat_laneq_s64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s64i x 2>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s64i x 2>)
   // CIR-SAME: [#cir.int<0> : !s32i] : !cir.vector<!s64i x 1>
@@ -1688,7 +1688,7 @@ float32x2_t test_splat_laneq_f32(float32x4_t v) {
   return (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 1, 41);
 
   // CIR-LABEL: test_splat_laneq_f32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.float x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.float x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.float x 4>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.float x 4>)
   // CIR-SAME: [#cir.int<1> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!cir.float x 2>
@@ -1704,7 +1704,7 @@ float64x1_t test_splat_laneq_f64(float64x2_t v) {
   return (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 0, 42);
 
   // CIR-LABEL: test_splat_laneq_f64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.double x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.double x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.double x 2>
   // CIR: [[TMP0:%.*]] = cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.double x 2>)
   // CIR-SAME: [#cir.int<0> : !s32i] : !cir.vector<!cir.double x 1>
@@ -1720,7 +1720,7 @@ uint8x8_t test_splat_laneq_u8(uint8x16_t v) {
   return (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 15, 48);
 
   // CIR-LABEL: test_splat_laneq_u8
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u8i x 16>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u8i x 16>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u8i x 16>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u8i x 16>)
   // CIR-SAME: [#cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i,
@@ -1736,7 +1736,7 @@ uint16x4_t test_splat_laneq_u16(uint16x8_t v) {
   return (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 7, 49);
 
   // CIR-LABEL: test_splat_laneq_u16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u16i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u16i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i] : !cir.vector<!u16i x 4>
@@ -1752,7 +1752,7 @@ uint32x2_t test_splat_laneq_u32(uint32x4_t v) {
   return (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 3, 50);
 
   // CIR-LABEL: test_splat_laneq_u32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u32i x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u32i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!u32i x 2>
@@ -1768,7 +1768,7 @@ uint64x1_t test_splat_laneq_u64(uint64x2_t v) {
   return (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)v, 0, 51);
 
   // CIR-LABEL: test_splat_laneq_u64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u64i x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u64i x 2>)
   // CIR-SAME: [#cir.int<0> : !s32i] : !cir.vector<!u64i x 1>
@@ -1803,7 +1803,7 @@ int16x8_t test_splatq_laneq_s16(int16x8_t v) {
   return (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 7, 33);
 
   // CIR-LABEL: test_splatq_laneq_s16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s16i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s16i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i,
@@ -1820,7 +1820,7 @@ int32x4_t test_splatq_laneq_s32(int32x4_t v) {
   return (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 3, 34);
 
   // CIR-LABEL: test_splatq_laneq_s32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s32i x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s32i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!s32i x 4>
@@ -1836,7 +1836,7 @@ int64x2_t test_splatq_laneq_s64(int64x2_t v) {
   return (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 0, 35);
 
   // CIR-LABEL: test_splatq_laneq_s64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!s64i x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!s64i x 2>)
   // CIR-SAME: [#cir.int<0> : !s32i, #cir.int<0> : !s32i] : !cir.vector<!s64i x 2>
@@ -1852,7 +1852,7 @@ float32x4_t test_splatq_laneq_f32(float32x4_t v) {
   return (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 3, 41);
 
   // CIR-LABEL: test_splatq_laneq_f32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.float x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.float x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.float x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.float x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!cir.float x 4>
@@ -1868,7 +1868,7 @@ float64x2_t test_splatq_laneq_f64(float64x2_t v) {
   return (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 0, 42);
 
   // CIR-LABEL: test_splatq_laneq_f64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!cir.double x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!cir.double x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!cir.double x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!cir.double x 2>)
   // CIR-SAME: [#cir.int<0> : !s32i, #cir.int<0> : !s32i] : !cir.vector<!cir.double x 2>
@@ -1884,7 +1884,7 @@ uint8x16_t test_splatq_laneq_u8(uint8x16_t v) {
   return (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 15, 48);
 
   // CIR-LABEL: test_splatq_laneq_u8
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u8i x 16>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u8i x 16>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u8i x 16>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u8i x 16>)
   // CIR-SAME: [#cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i, #cir.int<15> : !s32i,
@@ -1903,7 +1903,7 @@ uint16x8_t test_splatq_laneq_u16(uint16x8_t v) {
   return (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 7, 49);
 
   // CIR-LABEL: test_splatq_laneq_u16
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u16i x 8>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u16i x 8>)
   // CIR-SAME: [#cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i, #cir.int<7> : !s32i,
@@ -1920,7 +1920,7 @@ uint32x4_t test_splatq_laneq_u32(uint32x4_t v) {
   return (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 3, 50);
 
   // CIR-LABEL: test_splatq_laneq_u32
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u32i x 4>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u32i x 4>)
   // CIR-SAME: [#cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!u32i x 4>
@@ -1936,7 +1936,7 @@ uint64x2_t test_splatq_laneq_u64(uint64x2_t v) {
   return (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)v, 0, 51);
 
   // CIR-LABEL: test_splatq_laneq_u64
-  // CIR: [[VEC:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[VEC:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[POISON:%.*]] = cir.const #cir.poison : !cir.vector<!u64i x 2>
   // CIR: cir.vec.shuffle([[VEC]], [[POISON]] : !cir.vector<!u64i x 2>)
   // CIR-SAME: [#cir.int<0> : !s32i, #cir.int<0> : !s32i] : !cir.vector<!u64i x 2>
@@ -1954,7 +1954,7 @@ int16x4_t test_vpadal_s8(int16x4_t a, int8x8_t b) {
   // CIR-LABEL: vpadal_s8
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!s8i x 8>) -> !cir.vector<!s16i x 4>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 4>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 4>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!s16i x 4>
 
   // LLVM: {{.*}}test_vpadal_s8(<4 x i16>{{.*}}[[a:%.*]], <8 x i8>{{.*}}[[b:%.*]])
@@ -1967,7 +1967,7 @@ int32x2_t test_vpadal_s16(int32x2_t a, int16x4_t b) {
   // CIR-LABEL: vpadal_s16
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!s16i x 4>) -> !cir.vector<!s32i x 2>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s32i x 2>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s32i x 2>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!s32i x 2>
 
   // LLVM: {{.*}}test_vpadal_s16(<2 x i32>{{.*}}[[a:%.*]], <4 x i16>{{.*}}[[b:%.*]])
@@ -1981,7 +1981,7 @@ int64x1_t test_vpadal_s32(int64x1_t a, int32x2_t b) {
   // CIR-LABEL: vpadal_s32
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!s32i x 2>) -> !cir.vector<!s64i x 1>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!s64i x 1>
 
   // LLVM: {{.*}}test_vpadal_s32(<1 x i64>{{.*}}[[a:%.*]], <2 x i32>{{.*}}[[b:%.*]])
@@ -1995,7 +1995,7 @@ uint16x4_t test_vpadal_u8(uint16x4_t a, uint8x8_t b) {
   // CIR-LABEL: vpadal_u8
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!u8i x 8>) -> !cir.vector<!u16i x 4>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!u16i x 4>
 
   // LLVM: {{.*}}test_vpadal_u8(<4 x i16>{{.*}}[[a:%.*]], <8 x i8>{{.*}}[[b:%.*]])
@@ -2009,7 +2009,7 @@ uint32x2_t test_vpadal_u16(uint32x2_t a, uint16x4_t b) {
   // CIR-LABEL: vpadal_u16
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!u16i x 4>) -> !cir.vector<!u32i x 2>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!u32i x 2>
 
   // LLVM: {{.*}}test_vpadal_u16(<2 x i32>{{.*}}[[a:%.*]], <4 x i16>{{.*}}[[b:%.*]])
@@ -2023,7 +2023,7 @@ uint64x1_t test_vpadal_u32(uint64x1_t a, uint32x2_t b) {
   // CIR-LABEL: vpadal_u32
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!u32i x 2>) -> !cir.vector<!u64i x 1>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!u64i x 1>
 
   // LLVM: {{.*}}test_vpadal_u32(<1 x i64>{{.*}}[[a:%.*]], <2 x i32>{{.*}}[[b:%.*]])
@@ -2037,7 +2037,7 @@ int16x8_t test_vpadalq_s8(int16x8_t a, int8x16_t b) {
   // CIR-LABEL: vpadalq_s8
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!s8i x 16>) -> !cir.vector<!s16i x 8>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!s16i x 8>
 
   // LLVM: {{.*}}test_vpadalq_s8(<8 x i16>{{.*}}[[a:%.*]], <16 x i8>{{.*}}[[b:%.*]])
@@ -2051,7 +2051,7 @@ int32x4_t test_vpadalq_s16(int32x4_t a, int16x8_t b) {
   // CIR-LABEL: vpadalq_s16
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!s16i x 8>) -> !cir.vector<!s32i x 4>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!s32i x 4>
 
   // LLVM: {{.*}}test_vpadalq_s16(<4 x i32>{{.*}}[[a:%.*]], <8 x i16>{{.*}}[[b:%.*]])
@@ -2065,7 +2065,7 @@ int64x2_t test_vpadalq_s32(int64x2_t a, int32x4_t b) {
   // CIR-LABEL: vpadalq_s32
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.saddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!s32i x 4>) -> !cir.vector<!s64i x 2>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!s64i x 2>
 
   // LLVM: {{.*}}test_vpadalq_s32(<2 x i64>{{.*}}[[a:%.*]], <4 x i32>{{.*}}[[b:%.*]])
@@ -2079,7 +2079,7 @@ uint16x8_t test_vpadalq_u8(uint16x8_t a, uint8x16_t b) {
   // CIR-LABEL: vpadalq_u8
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!u8i x 16>) -> !cir.vector<!u16i x 8>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!u16i x 8>
 
   // LLVM: {{.*}}test_vpadalq_u8(<8 x i16>{{.*}}[[a:%.*]], <16 x i8>{{.*}}[[b:%.*]])
@@ -2093,7 +2093,7 @@ uint32x4_t test_vpadalq_u16(uint32x4_t a, uint16x8_t b) {
   // CIR-LABEL: vpadalq_u16
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!u16i x 8>) -> !cir.vector<!u32i x 4>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!u32i x 4>
 
   // LLVM: {{.*}}test_vpadalq_u16(<4 x i32>{{.*}}[[a:%.*]], <8 x i16>{{.*}}[[b:%.*]])
@@ -2107,7 +2107,7 @@ uint64x2_t test_vpadalq_u32(uint64x2_t a, uint32x4_t b) {
   // CIR-LABEL: vpadalq_u32
   // CIR: [[VPADAL_I:%.*]] = cir.llvm.intrinsic "aarch64.neon.uaddlp" {{%.*}} :
   // CIR-SAME: (!cir.vector<!u32i x 4>) -> !cir.vector<!u64i x 2>
-  // CIR: [[a:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[a:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: {{%.*}} = cir.binop(add, [[VPADAL_I]], [[a]]) : !cir.vector<!u64i x 2>
 
   // LLVM: {{.*}}test_vpadalq_u32(<2 x i64>{{.*}}[[a:%.*]], <4 x i32>{{.*}}[[b:%.*]])
diff --git a/clang/test/CIR/CodeGen/AArch64/neon.c b/clang/test/CIR/CodeGen/AArch64/neon.c
index 05e7518f4b4b..e32170afd2b8 100644
--- a/clang/test/CIR/CodeGen/AArch64/neon.c
+++ b/clang/test/CIR/CodeGen/AArch64/neon.c
@@ -5774,10 +5774,10 @@ int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) {
   return vrsra_n_s16(a, b, 3);
 
   // CIR-LABEL: vrsra_n_s16
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 4>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 4>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{.*}}, [[splat]] : (!cir.vector<!s16i x 4>, !cir.vector<!s16i x 4>) -> !cir.vector<!s16i x 4>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 4>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 4>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!s16i x 4>
 
   // LLVM-LABEL: test_vrsra_n_s16
@@ -5790,10 +5790,10 @@ int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) {
   return vrsra_n_s32(a, b, 3);
 
   // CIR-LABEL: vrsra_n_s32
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s32i x 2>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s32i x 2>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{.*}}, [[splat]] : (!cir.vector<!s32i x 2>, !cir.vector<!s32i x 2>) -> !cir.vector<!s32i x 2>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s32i x 2>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s32i x 2>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!s32i x 2>
 
   // LLVM-LABEL: test_vrsra_n_s32
@@ -5820,10 +5820,10 @@ int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) {
   return vrsraq_n_s16(a, b, 3);
 
   // CIR-LABEL: vrsraq_n_s16
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{.*}}, [[splat]] : (!cir.vector<!s16i x 8>, !cir.vector<!s16i x 8>) -> !cir.vector<!s16i x 8>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!s16i x 8>
 
   // LLVM-LABEL: test_vrsraq_n_s16
@@ -5836,10 +5836,10 @@ int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) {
   return vrsraq_n_s32(a, b, 3);
 
   // CIR-LABEL: vrsraq_n_s32
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{.*}}, [[splat]] : (!cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>) -> !cir.vector<!s32i x 4>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!s32i x 4>
 
   // LLVM-LABEL: test_vrsraq_n_s32
@@ -5852,10 +5852,10 @@ int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) {
   return vrsraq_n_s64(a, b, 3);
 
   // CIR-LABEL: vrsraq_n_s64
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{.*}}, [[splat]] : (!cir.vector<!s64i x 2>, !cir.vector<!s64i x 2>) -> !cir.vector<!s64i x 2>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!s64i x 2>
 
   // LLVM-LABEL: test_vrsraq_n_s64
@@ -5882,10 +5882,10 @@ uint16x4_t test_vrsra_n_u16(uint16x4_t a, uint16x4_t b) {
   return vrsra_n_u16(a, b, 3);
 
   // CIR-LABEL: vrsra_n_u16
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[splat]] : (!cir.vector<!u16i x 4>, !cir.vector<!s16i x 4>) -> !cir.vector<!u16i x 4>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u16i x 4>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u16i x 4>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!u16i x 4>
 
   // LLVM-LABEL: test_vrsra_n_u16
@@ -5898,10 +5898,10 @@ uint32x2_t test_vrsra_n_u32(uint32x2_t a, uint32x2_t b) {
   return vrsra_n_u32(a, b, 3);
 
   // CIR-LABEL: vrsra_n_u32
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[splat]] : (!cir.vector<!u32i x 2>, !cir.vector<!s32i x 2>) -> !cir.vector<!u32i x 2>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u32i x 2>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u32i x 2>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!u32i x 2>
 
   // LLVM-LABEL: test_vrsra_n_u32
@@ -5928,10 +5928,10 @@ uint16x8_t test_vrsraq_n_u16(uint16x8_t a, uint16x8_t b) {
   return vrsraq_n_u16(a, b, 3);
 
   // CIR-LABEL: vrsraq_n_u16
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[splat]] : (!cir.vector<!u16i x 8>, !cir.vector<!s16i x 8>) -> !cir.vector<!u16i x 8>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!u16i x 8>
 
   // LLVM-LABEL: test_vrsraq_n_u16
@@ -5944,10 +5944,10 @@ uint32x4_t test_vrsraq_n_u32(uint32x4_t a, uint32x4_t b) {
   return vrsraq_n_u32(a, b, 3);
 
   // CIR-LABEL: vrsraq_n_u32
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[splat]] : (!cir.vector<!u32i x 4>, !cir.vector<!s32i x 4>) -> !cir.vector<!u32i x 4>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!u32i x 4>
 
   // LLVM-LABEL: test_vrsraq_n_u32
@@ -5960,10 +5960,10 @@ uint64x2_t test_vrsraq_n_u64(uint64x2_t a, uint64x2_t b) {
   return vrsraq_n_u64(a, b, 3);
 
   // CIR-LABEL: vrsraq_n_u64
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[splat]] : (!cir.vector<!u64i x 2>, !cir.vector<!s64i x 2>) -> !cir.vector<!u64i x 2>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!u64i x 2>
 
   // LLVM-LABEL: test_vrsraq_n_u64
@@ -6418,11 +6418,11 @@ int8x8_t test_vshrn_n_s16(int16x8_t a) {
   return vshrn_n_s16(a, 3);
 
   // CIR-LABEL: vshrn_n_s16
-  // CIR: [[TGT:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[TGT:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: [[AMT:%.*]] = cir.const #cir.const_vector<[#cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i,
   // CIR-SAME: #cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i]> : !cir.vector<!s16i x 8>
   // CIR: [[RES:%.*]] = cir.shift(right, [[TGT]] : !cir.vector<!s16i x 8>, [[AMT]] : !cir.vector<!s16i x 8>) -> !cir.vector<!s16i x 8>
-  // CIR: {{%.*}} = cir.cast(integral, [[RES]] : !cir.vector<!s16i x 8>), !cir.vector<!s8i x 8>
+  // CIR: {{%.*}} = cir.cast integral [[RES]] : !cir.vector<!s16i x 8> -> !cir.vector<!s8i x 8>
 
   // LLVM: {{.*}}@test_vshrn_n_s16(<8 x i16>{{.*}}[[A:%.*]])
   // LLVM:   [[TMP2:%.*]] = ashr <8 x i16> {{.*}}, splat (i16 3)
@@ -6433,11 +6433,11 @@ int16x4_t test_vshrn_n_s32(int32x4_t a) {
   return vshrn_n_s32(a, 9);
 
   // CIR-LABEL: vshrn_n_s32
-  // CIR: [[TGT:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[TGT:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: [[AMT:%.*]] = cir.const #cir.const_vector<[#cir.int<9> : !s32i, #cir.int<9> : !s32i,
   // CIR-SAME: #cir.int<9> : !s32i, #cir.int<9> : !s32i]> : !cir.vector<!s32i x 4>
   // CIR: [[RES:%.*]] = cir.shift(right, [[TGT]] : !cir.vector<!s32i x 4>, [[AMT]] : !cir.vector<!s32i x 4>) -> !cir.vector<!s32i x 4>
-  // CIR: {{%.*}} = cir.cast(integral, [[RES]] : !cir.vector<!s32i x 4>), !cir.vector<!s16i x 4>
+  // CIR: {{%.*}} = cir.cast integral [[RES]] : !cir.vector<!s32i x 4> -> !cir.vector<!s16i x 4>
 
   // LLVM: {{.*}}@test_vshrn_n_s32(<4 x i32>{{.*}}[[A:%.*]])
   // LLVM:   [[TMP2:%.*]] = ashr <4 x i32> {{.*}}, splat (i32 9)
@@ -6448,10 +6448,10 @@ int32x2_t test_vshrn_n_s64(int64x2_t a) {
   return vshrn_n_s64(a, 19);
 
   // CIR-LABEL: vshrn_n_s64
-  // CIR: [[TGT:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[TGT:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: [[AMT:%.*]] = cir.const #cir.const_vector<[#cir.int<19> : !s64i, #cir.int<19> : !s64i]> : !cir.vector<!s64i x 2>
   // CIR: [[RES:%.*]] = cir.shift(right, [[TGT]] : !cir.vector<!s64i x 2>, [[AMT]] : !cir.vector<!s64i x 2>) -> !cir.vector<!s64i x 2>
-  // CIR: {{%.*}} = cir.cast(integral, [[RES]] : !cir.vector<!s64i x 2>), !cir.vector<!s32i x 2>
+  // CIR: {{%.*}} = cir.cast integral [[RES]] : !cir.vector<!s64i x 2> -> !cir.vector<!s32i x 2>
 
   // LLVM: {{.*}}@test_vshrn_n_s64(<2 x i64>{{.*}}[[A:%.*]])
   // LLVM:   [[TMP2:%.*]] = ashr <2 x i64> {{.*}}, splat (i64 19)
@@ -6462,11 +6462,11 @@ uint8x8_t test_vshrn_n_u16(uint16x8_t a) {
   return vshrn_n_u16(a, 3);
 
   // CIR-LABEL: vshrn_n_u16
-  // CIR: [[TGT:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[TGT:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[AMT:%.*]] = cir.const #cir.const_vector<[#cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i,
   // CIR-SAME: #cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i]> : !cir.vector<!u16i x 8>
   // CIR: [[RES:%.*]] = cir.shift(right, [[TGT]] : !cir.vector<!u16i x 8>, [[AMT]] : !cir.vector<!u16i x 8>) -> !cir.vector<!u16i x 8>
-  // CIR: {{%.*}} = cir.cast(integral, [[RES]] : !cir.vector<!u16i x 8>), !cir.vector<!u8i x 8>
+  // CIR: {{%.*}} = cir.cast integral [[RES]] : !cir.vector<!u16i x 8> -> !cir.vector<!u8i x 8>
 
   // LLVM: {{.*}}@test_vshrn_n_u16(<8 x i16>{{.*}}[[A:%.*]])
   // LLVM:   [[TMP2:%.*]] = lshr <8 x i16> {{.*}}, splat (i16 3)
@@ -6477,11 +6477,11 @@ uint16x4_t test_vshrn_n_u32(uint32x4_t a) {
   return vshrn_n_u32(a, 9);
 
   // CIR-LABEL: vshrn_n_u32
-  // CIR: [[TGT:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[TGT:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[AMT:%.*]] = cir.const #cir.const_vector<[#cir.int<9> : !u32i, #cir.int<9> : !u32i,
   // CIR-SAME: #cir.int<9> : !u32i, #cir.int<9> : !u32i]> : !cir.vector<!u32i x 4>
   // CIR: [[RES:%.*]] = cir.shift(right, [[TGT]] : !cir.vector<!u32i x 4>, [[AMT]] : !cir.vector<!u32i x 4>) -> !cir.vector<!u32i x 4>
-  // CIR: {{%.*}} = cir.cast(integral, [[RES]] : !cir.vector<!u32i x 4>), !cir.vector<!u16i x 4>
+  // CIR: {{%.*}} = cir.cast integral [[RES]] : !cir.vector<!u32i x 4> -> !cir.vector<!u16i x 4>
 
   // LLVM: {{.*}}@test_vshrn_n_u32(<4 x i32>{{.*}}[[A:%.*]])
   // LLVM:   [[TMP2:%.*]] = lshr <4 x i32> {{.*}}, splat (i32 9)
@@ -6492,10 +6492,10 @@ uint32x2_t test_vshrn_n_u64(uint64x2_t a) {
   return vshrn_n_u64(a, 19);
 
   // CIR-LABEL: vshrn_n_u64
-  // CIR: [[TGT:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[TGT:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[AMT:%.*]] = cir.const #cir.const_vector<[#cir.int<19> : !u64i, #cir.int<19> : !u64i]> : !cir.vector<!u64i x 2>
   // CIR: [[RES:%.*]] = cir.shift(right, [[TGT]] : !cir.vector<!u64i x 2>, [[AMT]] : !cir.vector<!u64i x 2>) -> !cir.vector<!u64i x 2>
-  // CIR: {{%.*}} = cir.cast(integral, [[RES]] : !cir.vector<!u64i x 2>), !cir.vector<!u32i x 2>
+  // CIR: {{%.*}} = cir.cast integral [[RES]] : !cir.vector<!u64i x 2> -> !cir.vector<!u32i x 2>
 
   // LLVM: {{.*}}@test_vshrn_n_u64(<2 x i64>{{.*}}[[A:%.*]])
   // LLVM:   [[TMP2:%.*]] = lshr <2 x i64> {{.*}}, splat (i64 19)
@@ -6751,7 +6751,7 @@ uint8x8_t test_vqrshrun_n_s16(int16x8_t a) {
   return vqrshrun_n_s16(a, 3);
   // CIR-LABEL: test_vqrshrun_n_s16
   // CIR: [[INTRN_ARG1:%.*]] = cir.const #cir.int<3> : !s32i
-  // CIR: [[INTRN_ARG0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[INTRN_ARG0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: {{%.*}} = cir.llvm.intrinsic "aarch64.neon.sqrshrun" [[INTRN_ARG0]], [[INTRN_ARG1]] :
   // CIR-SAME: (!cir.vector<!s16i x 8>, !s32i) -> !cir.vector<!u8i x 8>
 
@@ -6764,7 +6764,7 @@ uint16x4_t test_vqrshrun_n_s32(int32x4_t a) {
   return vqrshrun_n_s32(a, 9);
   // CIR-LABEL: test_vqrshrun_n_s32
   // CIR: [[INTRN_ARG1:%.*]] = cir.const #cir.int<9> : !s32i
-  // CIR: [[INTRN_ARG0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[INTRN_ARG0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: {{%.*}} = cir.llvm.intrinsic "aarch64.neon.sqrshrun" [[INTRN_ARG0]], [[INTRN_ARG1]] :
   // CIR-SAME: (!cir.vector<!s32i x 4>, !s32i) -> !cir.vector<!u16i x 4>
 
@@ -6776,7 +6776,7 @@ uint32x2_t test_vqrshrun_n_s64(int64x2_t a) {
   return vqrshrun_n_s64(a, 19);
   // CIR-LABEL: test_vqrshrun_n_s64
   // CIR: [[INTRN_ARG1:%.*]] = cir.const #cir.int<19> : !s32i
-  // CIR: [[INTRN_ARG0:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[INTRN_ARG0:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: {{%.*}} = cir.llvm.intrinsic "aarch64.neon.sqrshrun" [[INTRN_ARG0]], [[INTRN_ARG1]] :
   // CIR-SAME: (!cir.vector<!s64i x 2>, !s32i) -> !cir.vector<!u32i x 2>
 
@@ -6945,7 +6945,7 @@ int8x8_t test_vqrshrn_n_s16(int16x8_t a) {
 
   // CIR-LABEL: vqrshrn_n_s16
   // CIR: [[AMT:%.*]] = cir.const #cir.int<3> : !s32i
-  // CIR: [[VQRSHRN_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
+  // CIR: [[VQRSHRN_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
   // CIR: [[VQRSHRN_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.sqrshrn" [[VQRSHRN_N]], [[AMT]] :
   // CIR-SAME: (!cir.vector<!s16i x 8>, !s32i) -> !cir.vector<!s8i x 8>
 
@@ -6958,7 +6958,7 @@ int16x4_t test_vqrshrn_n_s32(int32x4_t a) {
 
   // CIR-LABEL: vqrshrn_n_s32
   // CIR: [[AMT:%.*]] = cir.const #cir.int<9> : !s32i
-  // CIR: [[VQRSHRN_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
+  // CIR: [[VQRSHRN_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
   // CIR: [[VQRSHRN_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.sqrshrn" [[VQRSHRN_N]], [[AMT]] :
   // CIR-SAME: (!cir.vector<!s32i x 4>, !s32i) -> !cir.vector<!s16i x 4>
 
@@ -6972,7 +6972,7 @@ int32x2_t test_vqrshrn_n_s64(int64x2_t a) {
 
   // CIR-LABEL: vqrshrn_n_s64
   // CIR: [[AMT:%.*]] = cir.const #cir.int<19> : !s32
-  // CIR: [[VQRSHRN_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
+  // CIR: [[VQRSHRN_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
   // CIR: [[VQRSHRN_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.sqrshrn" [[VQRSHRN_N]], [[AMT]] :
   // CIR-SAME: (!cir.vector<!s64i x 2>, !s32i) -> !cir.vector<!s32i x 2>
 
@@ -6985,7 +6985,7 @@ uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) {
 
   // CIR-LABEL: vqrshrn_n_u16
   // CIR: [[AMT:%.*]] = cir.const #cir.int<3> : !s32
-  // CIR: [[VQRSHRN_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
+  // CIR: [[VQRSHRN_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
   // CIR: [[VQRSHRN_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.uqrshrn" [[VQRSHRN_N]], [[AMT]] :
   // CIR-SAME: (!cir.vector<!u16i x 8>, !s32i) -> !cir.vector<!u8i x 8>
 
@@ -6998,7 +6998,7 @@ uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) {
 
   // CIR-LABEL: vqrshrn_n_u32
   // CIR: [[AMT:%.*]] = cir.const #cir.int<9> : !s32
-  // CIR: [[VQRSHRN_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
+  // CIR: [[VQRSHRN_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
   // CIR: [[VQRSHRN_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.uqrshrn" [[VQRSHRN_N]], [[AMT]] :
   // CIR-SAME: (!cir.vector<!u32i x 4>, !s32i) -> !cir.vector<!u16i x 4>
 
@@ -7011,7 +7011,7 @@ uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) {
 
   // CIR-LABEL: vqrshrn_n_u64
   // CIR: [[AMT:%.*]] = cir.const #cir.int<19> : !s32
-  // CIR: [[VQRSHRN_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
+  // CIR: [[VQRSHRN_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
   // CIR: [[VQRSHRN_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.uqrshrn" [[VQRSHRN_N]], [[AMT]] :
   // CIR-SAME: (!cir.vector<!u64i x 2>, !s32i) -> !cir.vector<!u32i x 2>
 
@@ -7083,7 +7083,7 @@ int16x8_t test_vshll_n_s8(int8x8_t a) {
   return vshll_n_s8(a, 3);
 
   // CIR-LABEL: vshll_n_s8
-  // CIR: [[SHIFT_TGT:%.*]] = cir.cast(integral, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 8>
+  // CIR: [[SHIFT_TGT:%.*]] = cir.cast integral {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 8>
   // CIR: [[SHIFT_AMT:%.*]] =  cir.const #cir.const_vector<[#cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i,
   // CIR-SAME: #cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i, #cir.int<3> : !s16i]> : !cir.vector<!s16i x 8>
   // CIR: {{%.*}} = cir.shift(left, [[SHIFT_TGT]] : !cir.vector<!s16i x 8>, [[SHIFT_AMT]] : !cir.vector<!s16i x 8>) -> !cir.vector<!s16i x 8>
@@ -7097,7 +7097,7 @@ int32x4_t test_vshll_n_s16(int16x4_t a) {
   return vshll_n_s16(a, 9);
 
   // CIR-LABEL: vshll_n_s16
-  // CIR: [[SHIFT_TGT:%.*]] = cir.cast(integral, {{%.*}} : !cir.vector<!s16i x 4>), !cir.vector<!s32i x 4>
+  // CIR: [[SHIFT_TGT:%.*]] = cir.cast integral {{%.*}} : !cir.vector<!s16i x 4> -> !cir.vector<!s32i x 4>
   // CIR: [[SHIFT_AMT:%.*]] =  cir.const #cir.const_vector<[#cir.int<9> : !s32i, #cir.int<9> : !s32i, #cir.int<9> :
   // CIR-SAME: !s32i, #cir.int<9> : !s32i]> : !cir.vector<!s32i x 4>
   // CIR: {{%.*}} = cir.shift(left, [[SHIFT_TGT]] : !cir.vector<!s32i x 4>, [[SHIFT_AMT]] : !cir.vector<!s32i x 4>) -> !cir.vector<!s32i x 4>
@@ -7111,7 +7111,7 @@ int64x2_t test_vshll_n_s32(int32x2_t a) {
   return vshll_n_s32(a, 19);
 
   // CIR-LABEL: vshll_n_s32
-  // CIR: [[SHIFT_TGT:%.*]] = cir.cast(integral, {{%.*}} : !cir.vector<!s32i x 2>), !cir.vector<!s64i x 2>
+  // CIR: [[SHIFT_TGT:%.*]] = cir.cast integral {{%.*}} : !cir.vector<!s32i x 2> -> !cir.vector<!s64i x 2>
   // CIR: [[SHIFT_AMT:%.*]] =  cir.const #cir.const_vector<[#cir.int<19> : !s64i, #cir.int<19> : !s64i]> : !cir.vector<!s64i x 2>
   // CIR: {{%.*}} = cir.shift(left, [[SHIFT_TGT]] : !cir.vector<!s64i x 2>, [[SHIFT_AMT]] : !cir.vector<!s64i x 2>)
 
@@ -7124,7 +7124,7 @@ uint16x8_t test_vshll_n_u8(uint8x8_t a) {
   return vshll_n_u8(a, 3);
 
   // CIR-LABEL: vshll_n_u8
-  // CIR: [[SHIFT_TGT:%.*]] = cir.cast(integral, {{%.*}} : !cir.vector<!u8i x 8>), !cir.vector<!u16i x 8>
+  // CIR: [[SHIFT_TGT:%.*]] = cir.cast integral {{%.*}} : !cir.vector<!u8i x 8> -> !cir.vector<!u16i x 8>
   // CIR: [[SHIFT_AMT:%.*]] =  cir.const #cir.const_vector<[#cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i,
   // CIR-SAME: #cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i, #cir.int<3> : !u16i]> : !cir.vector<!u16i x 8>
   // CIR: {{%.*}} = cir.shift(left, [[SHIFT_TGT]] : !cir.vector<!u16i x 8>, [[SHIFT_AMT]] : !cir.vector<!u16i x 8>)
@@ -7138,7 +7138,7 @@ uint32x4_t test_vshll_n_u16(uint16x4_t a) {
   return vshll_n_u16(a, 9);
 
   // CIR-LABEL: vshll_n_u16
-  // CIR: [[SHIFT_TGT:%.*]] = cir.cast(integral, {{%.*}} : !cir.vector<!u16i x 4>), !cir.vector<!u32i x 4>
+  // CIR: [[SHIFT_TGT:%.*]] = cir.cast integral {{%.*}} : !cir.vector<!u16i x 4> -> !cir.vector<!u32i x 4>
   // CIR: [[SHIFT_AMT:%.*]] =  cir.const #cir.const_vector<[#cir.int<9> : !u32i, #cir.int<9> : !u32i,
   // CIR-SAME: #cir.int<9> : !u32i, #cir.int<9> : !u32i]> : !cir.vector<!u32i x 4>
 
@@ -7151,7 +7151,7 @@ uint64x2_t test_vshll_n_u32(uint32x2_t a) {
   return vshll_n_u32(a, 19);
 
   // CIR-LABEL: vshll_n_u32
-  // CIR: [[SHIFT_TGT:%.*]] = cir.cast(integral, {{%.*}} : !cir.vector<!u32i x 2>), !cir.vector<!u64i x 2>
+  // CIR: [[SHIFT_TGT:%.*]] = cir.cast integral {{%.*}} : !cir.vector<!u32i x 2> -> !cir.vector<!u64i x 2>
   // CIR: [[SHIFT_AMT:%.*]] =  cir.const #cir.const_vector<[#cir.int<19> : !u64i, #cir.int<19> : !u64i]> : !cir.vector<!u64i x 2>
   // CIR: {{%.*}} = cir.shift(left, [[SHIFT_TGT]] : !cir.vector<!u64i x 2>, [[SHIFT_AMT]] : !cir.vector<!u64i x 2>)
 
@@ -7226,7 +7226,7 @@ int16x8_t test_vmovl_s8(int8x8_t a) {
   return vmovl_s8(a);
 
   // CIR-LABEL: vmovl_s8
-  // CIR: {{%.*}} = cir.cast(integral, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s16i x 8>
+  // CIR: {{%.*}} = cir.cast integral {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s16i x 8>
 
   // LLVM: {{.*}}test_vmovl_s8(<8 x i8>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVL_I:%.*]] = sext <8 x i8> {{.*}} to <8 x i16>
@@ -7236,7 +7236,7 @@ int32x4_t test_vmovl_s16(int16x4_t a) {
   return vmovl_s16(a);
 
   // CIR-LABEL: vmovl_s16
-  // CIR: {{%.*}} = cir.cast(integral, {{%.*}} : !cir.vector<!s16i x 4>), !cir.vector<!s32i x 4>
+  // CIR: {{%.*}} = cir.cast integral {{%.*}} : !cir.vector<!s16i x 4> -> !cir.vector<!s32i x 4>
 
   // LLVM: {{.*}}test_vmovl_s16(<4 x i16>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVL_I:%.*]] = sext <4 x i16> {{.*}} to <4 x i32>
@@ -7246,7 +7246,7 @@ int64x2_t test_vmovl_s32(int32x2_t a) {
   return vmovl_s32(a);
 
   // CIR-LABEL: vmovl_s32
-  // CIR: {{%.*}} = cir.cast(integral, {{%.*}} : !cir.vector<!s32i x 2>), !cir.vector<!s64i x 2>
+  // CIR: {{%.*}} = cir.cast integral {{%.*}} : !cir.vector<!s32i x 2> -> !cir.vector<!s64i x 2>
 
   // LLVM: {{.*}}test_vmovl_s32(<2 x i32>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVL_I:%.*]] = sext <2 x i32> {{.*}} to <2 x i64>
@@ -7256,7 +7256,7 @@ uint16x8_t test_vmovl_u8(uint8x8_t a) {
   return vmovl_u8(a);
 
   // CIR-LABEL: vmovl_u8
-  // CIR: {{%.*}} = cir.cast(integral, {{%.*}} : !cir.vector<!u8i x 8>), !cir.vector<!u16i x 8>
+  // CIR: {{%.*}} = cir.cast integral {{%.*}} : !cir.vector<!u8i x 8> -> !cir.vector<!u16i x 8>
 
   // LLVM: {{.*}}test_vmovl_u8(<8 x i8>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVL_I:%.*]] = zext <8 x i8> {{.*}} to <8 x i16>
@@ -7266,7 +7266,7 @@ uint32x4_t test_vmovl_u16(uint16x4_t a) {
   return vmovl_u16(a);
 
   // CIR-LABEL: vmovl_u16
-  // CIR: {{%.*}} = cir.cast(integral, {{%.*}} : !cir.vector<!u16i x 4>), !cir.vector<!u32i x 4>
+  // CIR: {{%.*}} = cir.cast integral {{%.*}} : !cir.vector<!u16i x 4> -> !cir.vector<!u32i x 4>
 
   // LLVM: {{.*}}test_vmovl_u16(<4 x i16>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVL_I:%.*]] = zext <4 x i16> {{.*}} to <4 x i32>
@@ -7276,7 +7276,7 @@ uint64x2_t test_vmovl_u32(uint32x2_t a) {
   return vmovl_u32(a);
 
   // CIR-LABEL: vmovl_u32
-  // CIR: {{%.*}} = cir.cast(integral, {{%.*}} : !cir.vector<!u32i x 2>), !cir.vector<!u64i x 2>
+  // CIR: {{%.*}} = cir.cast integral {{%.*}} : !cir.vector<!u32i x 2> -> !cir.vector<!u64i x 2>
 
   // LLVM: {{.*}}test_vmovl_u32(<2 x i32>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVL_I:%.*]] = zext <2 x i32> {{.*}} to <2 x i64>
@@ -9918,7 +9918,7 @@ int32_t test_vqrdmulhs_s32(int32_t a, int32_t b) {
 uint8x16_t test_vld1q_u8(uint8_t const *a) {
   return vld1q_u8(a);
   // CIR-LABEL: @test_vld1q_u8
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 16>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: cir.load align(1) %[[CAST]] : !cir.ptr<!cir.vector<!u8i x 16>>, !cir.vector<!u8i x 16>
 
   // LLVM-LABEL: @test_vld1q_u8
@@ -9928,7 +9928,7 @@ uint8x16_t test_vld1q_u8(uint8_t const *a) {
 uint16x8_t test_vld1q_u16(uint16_t const *a) {
   return vld1q_u16(a);
   // CIR-LABEL: @test_vld1q_u16
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u16i x 8>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u16i x 8>>
   // CIR: cir.load align(2) %[[CAST]] : !cir.ptr<!cir.vector<!u16i x 8>>, !cir.vector<!u16i x 8>
 
   // LLVM-LABEL: @test_vld1q_u16
@@ -9938,7 +9938,7 @@ uint16x8_t test_vld1q_u16(uint16_t const *a) {
 uint32x4_t test_vld1q_u32(uint32_t const *a) {
   return vld1q_u32(a);
   // CIR-LABEL: @test_vld1q_u32
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u32i x 4>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: cir.load align(4) %[[CAST]] : !cir.ptr<!cir.vector<!u32i x 4>>, !cir.vector<!u32i x 4>
 
   // LLVM-LABEL: @test_vld1q_u32
@@ -9948,7 +9948,7 @@ uint32x4_t test_vld1q_u32(uint32_t const *a) {
 uint64x2_t test_vld1q_u64(uint64_t const *a) {
   return vld1q_u64(a);
   // CIR-LABEL: @test_vld1q_u64
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u64i x 2>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u64i x 2>>
   // CIR: cir.load align(8) %[[CAST]] : !cir.ptr<!cir.vector<!u64i x 2>>, !cir.vector<!u64i x 2>
 
   // LLVM-LABEL: @test_vld1q_u64
@@ -9958,7 +9958,7 @@ uint64x2_t test_vld1q_u64(uint64_t const *a) {
 int8x16_t test_vld1q_s8(int8_t const *a) {
   return vld1q_s8(a);
   // CIR-LABEL: @test_vld1q_s8
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s8i x 16>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s8i x 16>>
   // CIR: cir.load align(1) %[[CAST]] : !cir.ptr<!cir.vector<!s8i x 16>>, !cir.vector<!s8i x 16>
 
   // LLVM-LABEL: @test_vld1q_s8
@@ -9968,7 +9968,7 @@ int8x16_t test_vld1q_s8(int8_t const *a) {
 int16x8_t test_vld1q_s16(int16_t const *a) {
   return vld1q_s16(a);
   // CIR-LABEL: @test_vld1q_s16
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s16i x 8>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: cir.load align(2) %[[CAST]] : !cir.ptr<!cir.vector<!s16i x 8>>, !cir.vector<!s16i x 8>
 
   // LLVM-LABEL: @test_vld1q_s16
@@ -9978,7 +9978,7 @@ int16x8_t test_vld1q_s16(int16_t const *a) {
 int32x4_t test_vld1q_s32(int32_t const *a) {
   return vld1q_s32(a);
   // CIR-LABEL: @test_vld1q_s32
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s32i x 4>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s32i x 4>>
   // CIR: cir.load align(4) %[[CAST]] : !cir.ptr<!cir.vector<!s32i x 4>>, !cir.vector<!s32i x 4>
 
   // LLVM-LABEL: @test_vld1q_s32
@@ -9988,7 +9988,7 @@ int32x4_t test_vld1q_s32(int32_t const *a) {
 int64x2_t test_vld1q_s64(int64_t const *a) {
   return vld1q_s64(a);
   // CIR-LABEL: @test_vld1q_s64
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s64i x 2>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s64i x 2>>
   // CIR: cir.load align(8) %[[CAST]] : !cir.ptr<!cir.vector<!s64i x 2>>, !cir.vector<!s64i x 2>
 
   // LLVM-LABEL: @test_vld1q_s64
@@ -11151,7 +11151,7 @@ int64x2_t test_vld1q_s64(int64_t const *a) {
 void test_vst1q_u8(uint8_t *a, uint8x16_t b) {
   vst1q_u8(a, b);
   // CIR-LABEL: @test_vst1q_u8
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u8i x 16>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u8i x 16>>
   // CIR: cir.store align(1) %{{.*}}, %[[CAST]] : !cir.vector<!u8i x 16>, !cir.ptr<!cir.vector<!u8i x 16>>
 
   // LLVM-LABEL: @test_vst1q_u8
@@ -11161,7 +11161,7 @@ void test_vst1q_u8(uint8_t *a, uint8x16_t b) {
 void test_vst1q_u16(uint16_t *a, uint16x8_t b) {
   vst1q_u16(a, b);
   // CIR-LABEL: @test_vst1q_u16
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u16i x 8>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u16i x 8>>
   // CIR: cir.store align(2) %{{.*}}, %[[CAST]] : !cir.vector<!u16i x 8>, !cir.ptr<!cir.vector<!u16i x 8>>
 
   // LLVM-LABEL: @test_vst1q_u16
@@ -11171,7 +11171,7 @@ void test_vst1q_u16(uint16_t *a, uint16x8_t b) {
 void test_vst1q_u32(uint32_t *a, uint32x4_t b) {
   vst1q_u32(a, b);
   // CIR-LABEL: @test_vst1q_u32
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u32i x 4>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u32i x 4>>
   // CIR: cir.store align(4) %{{.*}}, %[[CAST]] : !cir.vector<!u32i x 4>, !cir.ptr<!cir.vector<!u32i x 4>>
 
   // LLVM-LABEL: @test_vst1q_u32
@@ -11181,7 +11181,7 @@ void test_vst1q_u32(uint32_t *a, uint32x4_t b) {
 void test_vst1q_u64(uint64_t *a, uint64x2_t b) {
   vst1q_u64(a, b);
   // CIR-LABEL: @test_vst1q_u64
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!u64i x 2>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!u64i x 2>>
   // CIR: cir.store align(8) %{{.*}}, %[[CAST]] : !cir.vector<!u64i x 2>, !cir.ptr<!cir.vector<!u64i x 2>>
 
   // LLVM-LABEL: @test_vst1q_u64
@@ -11191,7 +11191,7 @@ void test_vst1q_u64(uint64_t *a, uint64x2_t b) {
 void test_vst1q_s8(int8_t *a, int8x16_t b) {
   vst1q_s8(a, b);
   // CIR-LABEL: @test_vst1q_s8
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s8i x 16>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s8i x 16>>
   // CIR: cir.store align(1) %{{.*}}, %[[CAST]] : !cir.vector<!s8i x 16>, !cir.ptr<!cir.vector<!s8i x 16>>
 
   // LLVM-LABEL: @test_vst1q_s8
@@ -11201,7 +11201,7 @@ void test_vst1q_s8(int8_t *a, int8x16_t b) {
 void test_vst1q_s16(int16_t *a, int16x8_t b) {
   vst1q_s16(a, b);
   // CIR-LABEL: @test_vst1q_s16
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s16i x 8>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s16i x 8>>
   // CIR: cir.store align(2) %{{.*}}, %[[CAST]] : !cir.vector<!s16i x 8>, !cir.ptr<!cir.vector<!s16i x 8>>
 
   // LLVM-LABEL: @test_vst1q_s16
@@ -11211,7 +11211,7 @@ void test_vst1q_s16(int16_t *a, int16x8_t b) {
 void test_vst1q_s32(int32_t *a, int32x4_t b) {
   vst1q_s32(a, b);
   // CIR-LABEL: @test_vst1q_s32
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s32i x 4>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s32i x 4>>
   // CIR: cir.store align(4) %{{.*}}, %[[CAST]] : !cir.vector<!s32i x 4>, !cir.ptr<!cir.vector<!s32i x 4>>
 
   // LLVM-LABEL: @test_vst1q_s32
@@ -11221,7 +11221,7 @@ void test_vst1q_s32(int32_t *a, int32x4_t b) {
 void test_vst1q_s64(int64_t *a, int64x2_t b) {
   vst1q_s64(a, b);
   // CIR-LABEL: @test_vst1q_s64
-  // CIR: %[[CAST:.*]] = cir.cast(bitcast, {{.*}} : !cir.ptr<!void>), !cir.ptr<!cir.vector<!s64i x 2>>
+  // CIR: %[[CAST:.*]] = cir.cast bitcast {{.*}} : !cir.ptr<!void> -> !cir.ptr<!cir.vector<!s64i x 2>>
   // CIR: cir.store align(8) %{{.*}}, %[[CAST]] : !cir.vector<!s64i x 2>, !cir.ptr<!cir.vector<!s64i x 2>>
 
   // LLVM-LABEL: @test_vst1q_s64
@@ -14705,7 +14705,7 @@ int64_t test_vrsrad_n_s64(int64_t a, int64_t b) {
   // CIR-LABEL: vrsrad_n_s64
   // CIR: [[TMP0:%.*]] = cir.const #cir.int<63> : !s32i
   // CIR: [[TMP1:%.*]] = cir.unary(minus, [[TMP0]]) : !s32i, !s32i
-  // CIR: [[TMP2:%.*]] = cir.cast(integral, [[TMP1]] : !s32i), !s64i
+  // CIR: [[TMP2:%.*]] = cir.cast integral [[TMP1]] : !s32i -> !s64i
   // CIR: [[TMP3:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{.*}}, [[TMP2]] : (!s64i, !s64i) -> !s64i
   // CIR: [[TMP4:%.*]] = cir.binop(add, {{.*}}, [[TMP3]]) : !s64i
 
@@ -14719,10 +14719,10 @@ int64x1_t test_vrsra_n_s64(int64x1_t a, int64x1_t b) {
   return vrsra_n_s64(a, b, 1);
 
   // CIR-LABEL: vrsra_n_s64
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.srshl" {{%.*}}, [[splat]] : (!cir.vector<!s64i x 1>, !cir.vector<!s64i x 1>) -> !cir.vector<!s64i x 1>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!s64i x 1>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!s64i x 1>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!s64i x 1>
 
   // LLVM-LABEL: test_vrsra_n_s64
@@ -14737,7 +14737,7 @@ uint64_t test_vrsrad_n_u64(uint64_t a, uint64_t b) {
   // CIR-LABEL:vrsrad_n_u64
   // CIR: [[TMP0:%.*]] = cir.const #cir.int<63> : !s32i
   // CIR: [[TMP1:%.*]] = cir.unary(minus, [[TMP0]]) : !s32i, !s32i
-  // CIR: [[TMP2:%.*]] = cir.cast(integral, [[TMP1]] : !s32i), !u64i
+  // CIR: [[TMP2:%.*]] = cir.cast integral [[TMP1]] : !s32i -> !u64i
   // CIR: [[TMP3:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[TMP2]] : (!u64i, !u64i) -> !u64i
   // CIR: [[TMP4:%.*]] = cir.binop(add, {{.*}}, [[TMP3]]) : !u64i
 
@@ -14751,10 +14751,10 @@ uint64x1_t test_vrsra_n_u64(uint64x1_t a, uint64x1_t b) {
   return vrsra_n_u64(a, b, 1);
 
   // CIR-LABEL: vrsra_n_u64
-  // CIR: [[VRSHR_N:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[VRSHR_N:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: [[splat:%.*]] = cir.const #cir.const_vector
   // CIR: [[VRSHR_N1:%.*]] = cir.llvm.intrinsic "aarch64.neon.urshl" {{.*}}, [[splat]] : (!cir.vector<!u64i x 1>, !cir.vector<!s64i x 1>) -> !cir.vector<!u64i x 1>
-  // CIR: [[TMP2:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 8>), !cir.vector<!u64i x 1>
+  // CIR: [[TMP2:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 8> -> !cir.vector<!u64i x 1>
   // CIR: cir.binop(add, [[TMP2]], [[VRSHR_N1]]) : !cir.vector<!u64i x 1>
 
   // LLVM-LABEL: test_vrsra_n_u64
@@ -18689,8 +18689,8 @@ uint64_t test_vaddlv_u32(uint32x2_t a) {
 uint8x8_t test_vmovn_u16(uint16x8_t a) {
   return vmovn_u16(a);
   // CIR-LABEL: vmovn_u16
-  // CIR: [[ARG:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u16i x 8>
-  // CIR: {{%.*}} = cir.cast(integral, [[ARG]] : !cir.vector<!u16i x 8>), !cir.vector<!u8i x 8>
+  // CIR: [[ARG:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u16i x 8>
+  // CIR: {{%.*}} = cir.cast integral [[ARG]] : !cir.vector<!u16i x 8> -> !cir.vector<!u8i x 8>
 
   // LLVM: {{.*}}@test_vmovn_u16(<8 x i16>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVN_I:%.*]] = trunc <8 x i16> {{.*}} to <8 x i8>
@@ -18700,8 +18700,8 @@ uint8x8_t test_vmovn_u16(uint16x8_t a) {
 uint16x4_t test_vmovn_u32(uint32x4_t a) {
   return vmovn_u32(a);
   // CIR-LABEL: vmovn_u32
-  // CIR: [[ARG:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u32i x 4>
-  // CIR: {{%.*}} = cir.cast(integral, [[ARG]] : !cir.vector<!u32i x 4>), !cir.vector<!u16i x 4>
+  // CIR: [[ARG:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u32i x 4>
+  // CIR: {{%.*}} = cir.cast integral [[ARG]] : !cir.vector<!u32i x 4> -> !cir.vector<!u16i x 4>
 
   // LLVM: {{.*}}@test_vmovn_u32(<4 x i32>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVN_I:%.*]] = trunc <4 x i32> {{.*}} to <4 x i16>
@@ -18710,8 +18710,8 @@ uint16x4_t test_vmovn_u32(uint32x4_t a) {
 uint32x2_t test_vmovn_u64(uint64x2_t a) {
   return vmovn_u64(a);
   // CIR-LABEL: vmovn_u64
-  // CIR: [[ARG:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!u64i x 2>
-  // CIR: {{%.*}} = cir.cast(integral, [[ARG]] : !cir.vector<!u64i x 2>), !cir.vector<!u32i x 2>
+  // CIR: [[ARG:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!u64i x 2>
+  // CIR: {{%.*}} = cir.cast integral [[ARG]] : !cir.vector<!u64i x 2> -> !cir.vector<!u32i x 2>
 
   // LLVM: {{.*}}@test_vmovn_u64(<2 x i64>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVN_I:%.*]] = trunc <2 x i64> {{.*}} to <2 x i32>
@@ -18720,8 +18720,8 @@ uint32x2_t test_vmovn_u64(uint64x2_t a) {
 int8x8_t test_vmovn_s16(int16x8_t a) {
   return vmovn_s16(a);
   // CIR-LABEL: vmovn_s16
-  // CIR: [[ARG:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s16i x 8>
-  // CIR: {{%.*}} = cir.cast(integral, [[ARG]] : !cir.vector<!s16i x 8>), !cir.vector<!s8i x 8>
+  // CIR: [[ARG:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s16i x 8>
+  // CIR: {{%.*}} = cir.cast integral [[ARG]] : !cir.vector<!s16i x 8> -> !cir.vector<!s8i x 8>
 
   // LLVM: {{.*}}@test_vmovn_s16(<8 x i16>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVN_I:%.*]] = trunc <8 x i16> {{.*}} to <8 x i8>
@@ -18730,8 +18730,8 @@ int8x8_t test_vmovn_s16(int16x8_t a) {
 int16x4_t test_vmovn_s32(int32x4_t a) {
   return vmovn_s32(a);
   // CIR-LABEL: vmovn_s32
-  // CIR: [[ARG:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s32i x 4>
-  // CIR: {{%.*}} = cir.cast(integral, [[ARG]] : !cir.vector<!s32i x 4>), !cir.vector<!s16i x 4>
+  // CIR: [[ARG:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s32i x 4>
+  // CIR: {{%.*}} = cir.cast integral [[ARG]] : !cir.vector<!s32i x 4> -> !cir.vector<!s16i x 4>
 
   // LLVM: {{.*}}@test_vmovn_s32(<4 x i32>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVN_I:%.*]] = trunc <4 x i32> {{.*}} to <4 x i16>
@@ -18740,8 +18740,8 @@ int16x4_t test_vmovn_s32(int32x4_t a) {
 int32x2_t test_vmovn_s64(int64x2_t a) {
   return vmovn_s64(a);
   // CIR-LABEL: vmovn_s64
-  // CIR: [[ARG:%.*]] = cir.cast(bitcast, {{%.*}} : !cir.vector<!s8i x 16>), !cir.vector<!s64i x 2>
-  // CIR: {{%.*}} = cir.cast(integral, [[ARG]] : !cir.vector<!s64i x 2>), !cir.vector<!s32i x 2>
+  // CIR: [[ARG:%.*]] = cir.cast bitcast {{%.*}} : !cir.vector<!s8i x 16> -> !cir.vector<!s64i x 2>
+  // CIR: {{%.*}} = cir.cast integral [[ARG]] : !cir.vector<!s64i x 2> -> !cir.vector<!s32i x 2>
 
   // LLVM: {{.*}}@test_vmovn_s64(<2 x i64>{{.*}}[[A:%.*]])
   // LLVM: [[VMOVN_I:%.*]] = trunc <2 x i64> {{.*}} to <2 x i32>
diff --git a/clang/test/CIR/CodeGen/CUDA/printf.cu b/clang/test/CIR/CodeGen/CUDA/printf.cu
index 250da31432a9..e3ae515c862c 100644
--- a/clang/test/CIR/CodeGen/CUDA/printf.cu
+++ b/clang/test/CIR/CodeGen/CUDA/printf.cu
@@ -19,7 +19,7 @@ __device__ void printer() {
 // CIR-DEVICE:   %[[#Zero:]] = cir.const #cir.int<0> : !s32i loc(#loc5)
 // CIR-DEVICE:   %[[#Field0:]] = cir.get_member %0[0]
 // CIR-DEVICE:   cir.store align(4) %[[#Zero]], %[[#Field0]]
-// CIR-DEVICE:   %[[#Output:]] = cir.cast(bitcast, %[[#Packed]] : !cir.ptr<!rec_anon_struct>)
+// CIR-DEVICE:   %[[#Output:]] = cir.cast bitcast %[[#Packed]] : !cir.ptr<!rec_anon_struct>
 // CIR-DEVICE:   cir.call @vprintf(%{{.+}}, %[[#Output]])
 // CIR-DEVICE:   cir.return
 // CIR-DEVICE: }
diff --git a/clang/test/CIR/CodeGen/CUDA/registration.cu b/clang/test/CIR/CodeGen/CUDA/registration.cu
index fad25c6e77ec..834e45204b77 100644
--- a/clang/test/CIR/CodeGen/CUDA/registration.cu
+++ b/clang/test/CIR/CodeGen/CUDA/registration.cu
@@ -53,9 +53,9 @@ __global__ void fn() {}
 // CIR-HOST: cir.func internal private @__cuda_register_globals(%[[FatbinHandle:[a-zA-Z0-9]+]]{{.*}}) {
 // CIR-HOST:   %[[#NULL:]] = cir.const #cir.ptr<null>
 // CIR-HOST:   %[[#T1:]] = cir.get_global @".str_Z2fnv"
-// CIR-HOST:   %[[#DeviceFn:]] = cir.cast(bitcast, %[[#T1]]
+// CIR-HOST:   %[[#DeviceFn:]] = cir.cast bitcast %[[#T1]]
 // CIR-HOST:   %[[#T2:]] = cir.get_global @_Z17__device_stub__fnv
-// CIR-HOST:   %[[#HostFn:]] = cir.cast(bitcast, %[[#T2]]
+// CIR-HOST:   %[[#HostFn:]] = cir.cast bitcast %[[#T2]]
 // CIR-HOST:   %[[#MinusOne:]] = cir.const #cir.int<-1>
 // CIR-HOST:   cir.call @__cudaRegisterFunction(
 // CIR-HOST-SAME: %[[FatbinHandle]],
diff --git a/clang/test/CIR/CodeGen/CUDA/simple.cu b/clang/test/CIR/CodeGen/CUDA/simple.cu
index d4fa3a63d6a2..2d4f12da39e0 100644
--- a/clang/test/CIR/CodeGen/CUDA/simple.cu
+++ b/clang/test/CIR/CodeGen/CUDA/simple.cu
@@ -50,7 +50,7 @@ __global__ void global_fn(int a) {}
 
 // CIR-HOST: @_Z24__device_stub__global_fni{{.*}}extra([[Kernel]])
 // CIR-HOST: %[[#CIRKernelArgs:]] = cir.alloca {{.*}}"kernel_args"
-// CIR-HOST: %[[#Decayed:]] = cir.cast(array_to_ptrdecay, %[[#CIRKernelArgs]]
+// CIR-HOST: %[[#Decayed:]] = cir.cast array_to_ptrdecay %[[#CIRKernelArgs]]
 // CIR-HOST: cir.call @__cudaPopCallConfiguration
 // CIR-HOST: cir.get_global @_Z24__device_stub__global_fni
 // CIR-HOST: cir.call @cudaLaunchKernel
@@ -78,7 +78,7 @@ int main() {
 // CIR-HOST: cir.call @_ZN4dim3C1Ejjj
 // CIR-HOST: cir.call @_ZN4dim3C1Ejjj
 // CIR-HOST: [[Push:%[0-9]+]] = cir.call @__cudaPushCallConfiguration
-// CIR-HOST: [[ConfigOK:%[0-9]+]] = cir.cast(int_to_bool, [[Push]]
+// CIR-HOST: [[ConfigOK:%[0-9]+]] = cir.cast int_to_bool [[Push]]
 // CIR-HOST: cir.if [[ConfigOK]] {
 // CIR-HOST: } else {
 // CIR-HOST:   [[Arg:%[0-9]+]] = cir.const #cir.int<1>
diff --git a/clang/test/CIR/CodeGen/OpenCL/array-decay.cl b/clang/test/CIR/CodeGen/OpenCL/array-decay.cl
index 747990610bfa..9ba283587309 100644
--- a/clang/test/CIR/CodeGen/OpenCL/array-decay.cl
+++ b/clang/test/CIR/CodeGen/OpenCL/array-decay.cl
@@ -9,7 +9,7 @@ kernel void func1(global int *data) {
     local int arr[32];
 
     local int *ptr = arr;
-    // CIR:      cir.cast(array_to_ptrdecay, %{{[0-9]+}} : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_local)>), !cir.ptr<!s32i, addrspace(offload_local)>
+    // CIR:      cir.cast array_to_ptrdecay %{{[0-9]+}} : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_local)> -> !cir.ptr<!s32i, addrspace(offload_local)>
     // CIR-NEXT: cir.store{{.*}} %{{[0-9]+}}, %{{[0-9]+}} : !cir.ptr<!s32i, addrspace(offload_local)>, !cir.ptr<!cir.ptr<!s32i, addrspace(offload_local)>, addrspace(offload_private)>
 
     // LLVM: store ptr addrspace(3) @func1.arr, ptr %{{[0-9]+}}
diff --git a/clang/test/CIR/CodeGen/String.cpp b/clang/test/CIR/CodeGen/String.cpp
index 6e5b8e046926..c5f77a792139 100644
--- a/clang/test/CIR/CodeGen/String.cpp
+++ b/clang/test/CIR/CodeGen/String.cpp
@@ -26,7 +26,7 @@ void test() {
 // CHECK-NEXT:   cir.store{{.*}} %3, %2 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CHECK-NEXT:   %4 = cir.get_member %1[1] {name = "size"} : !cir.ptr<!rec_String> -> !cir.ptr<!s64i>
 // CHECK-NEXT:   %5 = cir.const #cir.int<0> : !s32i
-// CHECK-NEXT:   %6 = cir.cast(integral, %5 : !s32i), !s64i
+// CHECK-NEXT:   %6 = cir.cast integral %5 : !s32i -> !s64i
 // CHECK-NEXT:   cir.store{{.*}} %6, %4 : !s64i, !cir.ptr<!s64i>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
@@ -41,7 +41,7 @@ void test() {
 // 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:   %7 = cir.cast(integral, %6 : !s32i), !s64i
+// CHECK-NEXT:   %7 = cir.cast integral %6 : !s32i -> !s64i
 // CHECK-NEXT:   cir.store{{.*}} %7, %5 : !s64i, !cir.ptr<!s64i>
 // CHECK-NEXT:   cir.return
 // CHECK-NEXT: }
diff --git a/clang/test/CIR/CodeGen/X86/avx-builtins.c b/clang/test/CIR/CodeGen/X86/avx-builtins.c
index 53a3fd4d1cf9..48202c7185df 100644
--- a/clang/test/CIR/CodeGen/X86/avx-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx-builtins.c
@@ -31,7 +31,7 @@
 __m256 test_mm256_undefined_ps(void) {
   // CIR-X64-LABEL: _mm256_undefined_ps
   // CIR-X64: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 4>
-  // CIR-X64: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 4>), !cir.vector<!cir.float x 8>
+  // CIR-X64: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 4> -> !cir.vector<!cir.float x 8>
   // CIR-X64: cir.return %{{.*}} : !cir.vector<!cir.float x 8>
 
   // LLVM-X64-LABEL: test_mm256_undefined_ps
@@ -58,7 +58,7 @@ __m256d test_mm256_undefined_pd(void) {
 __m256i test_mm256_undefined_si256(void) {
   // CIR-X64-LABEL: _mm256_undefined_si256
   // CIR-X64: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 4>
-  // CIR-X64: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 4>), !cir.vector<!s64i x 4>
+  // CIR-X64: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 4> -> !cir.vector<!s64i x 4>
   // CIR-X64: cir.return %{{.*}} : !cir.vector<!s64i x 4>
   
   // LLVM-X64-LABEL: test_mm256_undefined_si256
@@ -71,7 +71,7 @@ __m256i test_mm256_undefined_si256(void) {
 int test_mm256_extract_epi8(__m256i A) {
   // CIR-CHECK-LABEL: test_mm256_extract_epi8
   // CIR-CHECK %{{.*}} = cir.vec.extract %{{.*}}[%{{.*}} : {{!u32i|!u64i}}] : !cir.vector<!s8i x 32>
-  // CIR-CHECK %{{.*}} = cir.cast(integral, %{{.*}} : !u8i), !s32i
+  // CIR-CHECK %{{.*}} = cir.cast integral %{{.*}} : !u8i -> !s32i
 
   // LLVM-CHECK-LABEL: test_mm256_extract_epi8
   // LLVM-CHECK: extractelement <32 x i8> %{{.*}}, {{i32|i64}} 31
@@ -82,7 +82,7 @@ int test_mm256_extract_epi8(__m256i A) {
 int test_mm256_extract_epi16(__m256i A) {
   // CIR-CHECK-LABEL: test_mm256_extract_epi16
   // CIR-CHECK %{{.*}} = cir.vec.extract %{{.*}}[%{{.*}} : {{!u32i|!u64i}}] : !cir.vector<!s16i x 16>
-  // CIR-CHECK %{{.*}} = cir.cast(integral, %{{.*}} : !u16i), !s32i
+  // CIR-CHECK %{{.*}} = cir.cast integral %{{.*}} : !u16i -> !s32i
 
   // LLVM-CHECK-LABEL: test_mm256_extract_epi16
   // LLVM-CHECK: extractelement <16 x i16> %{{.*}}, {{i32|i64}} 15
diff --git a/clang/test/CIR/CodeGen/X86/avx-shuffle-builtins.c b/clang/test/CIR/CodeGen/X86/avx-shuffle-builtins.c
index ac46350fb1f0..0848a8bce7ff 100644
--- a/clang/test/CIR/CodeGen/X86/avx-shuffle-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx-shuffle-builtins.c
@@ -55,11 +55,11 @@ __m256 test_mm256_insertf128_ps_1(__m256 a, __m128 b) {
 }
 
 // CIR-LABEL: @test_mm256_insertf128_si256_0(
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, %{{.*}} : !cir.vector<!s64i x 4>), !cir.vector<!s32i x 8>
-// CIR: [[TMP1:%.*]] = cir.cast(bitcast, %{{.*}} : !cir.vector<!s64i x 2>), !cir.vector<!s32i x 4>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast %{{.*}} : !cir.vector<!s64i x 4> -> !cir.vector<!s32i x 8>
+// CIR: [[TMP1:%.*]] = cir.cast bitcast %{{.*}} : !cir.vector<!s64i x 2> -> !cir.vector<!s32i x 4>
 // CIR: %{{.*}} = cir.vec.shuffle([[TMP1]], %{{.*}} : !cir.vector<!s32i x 4>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i, #cir.int<5> : !s32i, #cir.int<6> : !s32i, #cir.int<7> : !s32i] : !cir.vector<!s32i x 8>
 // CIR-NEXT: %{{.*}} = cir.vec.shuffle([[TMP0]], %{{.*}} : !cir.vector<!s32i x 8>) [#cir.int<8> : !s32i, #cir.int<9> : !s32i, #cir.int<10> : !s32i, #cir.int<11> : !s32i, #cir.int<4> : !s32i, #cir.int<5> : !s32i, #cir.int<6> : !s32i, #cir.int<7> : !s32i] : !cir.vector<!s32i x 8>
-// CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.vector<!s32i x 8>), !cir.vector<!s64i x 4>
+// CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !cir.vector<!s32i x 8> -> !cir.vector<!s64i x 4>
 // CIR: cir.return %{{.*}} : !cir.vector<!s64i x 4>
 
 // LLVM-LABEL: @test_mm256_insertf128_si256_0
@@ -75,11 +75,11 @@ __m256i test_mm256_insertf128_si256_0(__m256i a, __m128i b) {
 }
 
 // CIR-LABEL: @test_mm256_insertf128_si256_1(
-// CIR: [[TMP0:%.*]] = cir.cast(bitcast, %{{.*}} : !cir.vector<!s64i x 4>), !cir.vector<!s32i x 8>
-// CIR: [[TMP1:%.*]] = cir.cast(bitcast, %{{.*}} : !cir.vector<!s64i x 2>), !cir.vector<!s32i x 4>
+// CIR: [[TMP0:%.*]] = cir.cast bitcast %{{.*}} : !cir.vector<!s64i x 4> -> !cir.vector<!s32i x 8>
+// CIR: [[TMP1:%.*]] = cir.cast bitcast %{{.*}} : !cir.vector<!s64i x 2> -> !cir.vector<!s32i x 4>
 // CIR: %{{.*}} = cir.vec.shuffle([[TMP1]], %{{.*}} : !cir.vector<!s32i x 4>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i, #cir.int<5> : !s32i, #cir.int<6> : !s32i, #cir.int<7> : !s32i] : !cir.vector<!s32i x 8>
 // CIR-NEXT: %{{.*}} = cir.vec.shuffle([[TMP0]], %{{.*}} : !cir.vector<!s32i x 8>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<8> : !s32i, #cir.int<9> : !s32i, #cir.int<10> : !s32i, #cir.int<11> : !s32i] : !cir.vector<!s32i x 8>
-// CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.vector<!s32i x 8>), !cir.vector<!s64i x 4>
+// CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !cir.vector<!s32i x 8> -> !cir.vector<!s64i x 4>
 // CIR: cir.return %{{.*}} : !cir.vector<!s64i x 4>
 
 // LLVM-LABEL: @test_mm256_insertf128_si256_1
diff --git a/clang/test/CIR/CodeGen/X86/avx10_2_512bf16-builtins.c b/clang/test/CIR/CodeGen/X86/avx10_2_512bf16-builtins.c
index 3cdf01be94b7..87cdcd9b6b7c 100644
--- a/clang/test/CIR/CodeGen/X86/avx10_2_512bf16-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx10_2_512bf16-builtins.c
@@ -9,7 +9,7 @@ __m512bh test_mm512_undefined_pbh(void) {
 
   // CIR-LABEL: _mm512_undefined_pbh
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 8>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 8>), !cir.vector<!cir.bf16 x 32>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 8> -> !cir.vector<!cir.bf16 x 32>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.bf16 x 32>
 
   // LLVM-LABEL: test_mm512_undefined_pbh
diff --git a/clang/test/CIR/CodeGen/X86/avx10_2bf16-builtins.c b/clang/test/CIR/CodeGen/X86/avx10_2bf16-builtins.c
index 0f8ab4628f73..d39def212d01 100644
--- a/clang/test/CIR/CodeGen/X86/avx10_2bf16-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx10_2bf16-builtins.c
@@ -8,7 +8,7 @@
 __m128bh test_mm_undefined_pbh(void) {
   // CIR-LABEL: _mm_undefined_pbh
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 2>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 2>), !cir.vector<!cir.bf16 x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 2> -> !cir.vector<!cir.bf16 x 8>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.bf16 x 8>
 
   // LLVM-LABEL: @test_mm_undefined_pbh
@@ -21,7 +21,7 @@ __m128bh test_mm_undefined_pbh(void) {
 __m256bh test_mm256_undefined_pbh(void) {
   // CIR-LABEL: _mm256_undefined_pbh
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 4>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 4>), !cir.vector<!cir.bf16 x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 4> -> !cir.vector<!cir.bf16 x 16>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.bf16 x 16>
 
   // LLVM-LABEL: @test_mm256_undefined_pbh
diff --git a/clang/test/CIR/CodeGen/X86/avx512bw-builtins.c b/clang/test/CIR/CodeGen/X86/avx512bw-builtins.c
index 1d0165634187..35e2cfe9d75b 100644
--- a/clang/test/CIR/CodeGen/X86/avx512bw-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx512bw-builtins.c
@@ -36,8 +36,8 @@ void test_mm512_mask_storeu_epi8(void *__P, __mmask64 __U, __m512i __A) {
 
 __m512i test_mm512_movm_epi16(__mmask32 __A) {
   // CIR-LABEL: _mm512_movm_epi16
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u32i), !cir.vector<!cir.int<s, 1> x 32>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 32>), !cir.vector<!s16i x 32>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u32i -> !cir.vector<!cir.int<s, 1> x 32>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 32> -> !cir.vector<!s16i x 32>
   // LLVM-LABEL: @test_mm512_movm_epi16
   // LLVM:  %{{.*}} = bitcast i32 %{{.*}} to <32 x i1>
   // LLVM:  %{{.*}} = sext <32 x i1> %{{.*}} to <32 x i16>
diff --git a/clang/test/CIR/CodeGen/X86/avx512dq-builtins.c b/clang/test/CIR/CodeGen/X86/avx512dq-builtins.c
index cf0853b36223..db12a3cef291 100644
--- a/clang/test/CIR/CodeGen/X86/avx512dq-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx512dq-builtins.c
@@ -8,8 +8,8 @@
 
 __m512i test_mm512_movm_epi64(__mmask8 __A) {
   // CIR-LABEL: _mm512_movm_epi64
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u8i), !cir.vector<!cir.int<s, 1> x 8>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 8>), !cir.vector<!s64i x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u8i -> !cir.vector<!cir.int<s, 1> x 8>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 8> -> !cir.vector<!s64i x 8>
   // LLVM-LABEL: @test_mm512_movm_epi64
   // LLVM: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
   // LLVM: %{{.*}} = sext <8 x i1> %{{.*}} to <8 x i64>
diff --git a/clang/test/CIR/CodeGen/X86/avx512f-builtins.c b/clang/test/CIR/CodeGen/X86/avx512f-builtins.c
index 8fcd0a457e3a..c63857578fb0 100644
--- a/clang/test/CIR/CodeGen/X86/avx512f-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx512f-builtins.c
@@ -18,7 +18,7 @@
 __m512 test_mm512_undefined(void) {
   // CIR-LABEL: _mm512_undefined
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 8>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 8>), !cir.vector<!cir.float x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 8> -> !cir.vector<!cir.float x 16>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.float x 16>
 
   // LLVM-LABEL: test_mm512_undefined
@@ -31,7 +31,7 @@ __m512 test_mm512_undefined(void) {
 __m512 test_mm512_undefined_ps(void) {
   // CIR-LABEL: _mm512_undefined_ps
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 8>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 8>), !cir.vector<!cir.float x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 8> -> !cir.vector<!cir.float x 16>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.float x 16>
 
   // LLVM-LABEL: test_mm512_undefined_ps
@@ -56,7 +56,7 @@ __m512d test_mm512_undefined_pd(void) {
 __m512i test_mm512_undefined_epi32(void) {
   // CIR-LABEL: _mm512_undefined_epi32
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 8>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 8>), !cir.vector<!s64i x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 8> -> !cir.vector<!s64i x 8>
   // CIR: cir.return %{{.*}} : !cir.vector<!s64i x 8>
 
   // LLVM-LABEL: test_mm512_undefined_epi32
diff --git a/clang/test/CIR/CodeGen/X86/avx512fp16-builtins.c b/clang/test/CIR/CodeGen/X86/avx512fp16-builtins.c
index d46fd6be21aa..2ac3aca29892 100644
--- a/clang/test/CIR/CodeGen/X86/avx512fp16-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx512fp16-builtins.c
@@ -9,7 +9,7 @@
 __m128h test_mm_undefined_ph(void) {
   // CIR-LABEL: _mm_undefined_ph
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 2>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 2>), !cir.vector<!cir.f16 x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 2> -> !cir.vector<!cir.f16 x 8>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.f16 x 8>
 
   // LLVM-LABEL: @test_mm_undefined_ph
@@ -22,7 +22,7 @@ __m128h test_mm_undefined_ph(void) {
 __m256h test_mm256_undefined_ph(void) {
   // CIR-LABEL: _mm256_undefined_ph
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 4>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 4>), !cir.vector<!cir.f16 x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 4> -> !cir.vector<!cir.f16 x 16>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.f16 x 16>
 
   // LLVM-LABEL: @test_mm256_undefined_ph
@@ -35,7 +35,7 @@ __m256h test_mm256_undefined_ph(void) {
 __m512h test_mm512_undefined_ph(void) {
   // CIR-LABEL: _mm512_undefined_ph
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 8>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 8>), !cir.vector<!cir.f16 x 32>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 8> -> !cir.vector<!cir.f16 x 32>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.f16 x 32>
 
   // LLVM-LABEL: @test_mm512_undefined_ph
diff --git a/clang/test/CIR/CodeGen/X86/avx512vlbw-buiiltins.c b/clang/test/CIR/CodeGen/X86/avx512vlbw-buiiltins.c
index 19a3c6ce47d3..b67f880413ec 100644
--- a/clang/test/CIR/CodeGen/X86/avx512vlbw-buiiltins.c
+++ b/clang/test/CIR/CodeGen/X86/avx512vlbw-buiiltins.c
@@ -57,8 +57,8 @@ void test_mm256_mask_storeu_pd(void *__P, __mmask8 __U, __m256d __A) {
 
 __m128i test_mm_movm_epi8(__mmask16 __A) {
   // CIR-LABEL: _mm_movm_epi8
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u16i), !cir.vector<!cir.int<s, 1> x 16>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 16>), !cir.vector<{{!s8i|!u8i}} x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u16i -> !cir.vector<!cir.int<s, 1> x 16>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 16> -> !cir.vector<{{!s8i|!u8i}} x 16>
 
   // LLVM-LABEL: @test_mm_movm_epi8
   // LLVM: %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
@@ -68,8 +68,8 @@ __m128i test_mm_movm_epi8(__mmask16 __A) {
 
 __m256i test_mm256_movm_epi8(__mmask32 __A) {
   // CIR-LABEL: _mm256_movm_epi8
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u32i), !cir.vector<!cir.int<s, 1> x 32>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 32>), !cir.vector<{{!s8i|!u8i}} x 32>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u32i -> !cir.vector<!cir.int<s, 1> x 32>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 32> -> !cir.vector<{{!s8i|!u8i}} x 32>
 
   // LLVM-LABEL: @test_mm256_movm_epi8
   // LLVM: %{{.*}} = bitcast i32 %{{.*}} to <32 x i1>
@@ -79,8 +79,8 @@ __m256i test_mm256_movm_epi8(__mmask32 __A) {
 
 __m512i test_mm512_movm_epi8(__mmask64 __A) {
   // CIR-LABEL: _mm512_movm_epi8
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u64i), !cir.vector<!cir.int<s, 1> x 64>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 64>), !cir.vector<{{!s8i|!u8i}} x 64>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u64i -> !cir.vector<!cir.int<s, 1> x 64>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 64> -> !cir.vector<{{!s8i|!u8i}} x 64>
 
   // LLVM-LABEL: @test_mm512_movm_epi8
   // LLVM:  %{{.*}} = bitcast i64 %{{.*}} to <64 x i1>
@@ -90,8 +90,8 @@ __m512i test_mm512_movm_epi8(__mmask64 __A) {
 
 __m128i test_mm_movm_epi16(__mmask8 __A) {
   // CIR-LABEL: _mm_movm_epi16
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u8i), !cir.vector<!cir.int<s, 1> x 8>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 8>), !cir.vector<!s16i x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u8i -> !cir.vector<!cir.int<s, 1> x 8>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 8> -> !cir.vector<!s16i x 8>
 
   // LLVM-LABEL: @test_mm_movm_epi16
   // LLVM: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
@@ -101,8 +101,8 @@ __m128i test_mm_movm_epi16(__mmask8 __A) {
 
 __m256i test_mm256_movm_epi16(__mmask16 __A) {
   // CIR-LABEL: _mm256_movm_epi16
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u16i), !cir.vector<!cir.int<s, 1> x 16>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 16>), !cir.vector<!s16i x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u16i -> !cir.vector<!cir.int<s, 1> x 16>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 16> -> !cir.vector<!s16i x 16>
 
   // LLVM-LABEL: @test_mm256_movm_epi16
   // LLVM: %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
diff --git a/clang/test/CIR/CodeGen/X86/avx512vldq-builtins.c b/clang/test/CIR/CodeGen/X86/avx512vldq-builtins.c
index b202405e824a..349a50285a7a 100644
--- a/clang/test/CIR/CodeGen/X86/avx512vldq-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/avx512vldq-builtins.c
@@ -8,9 +8,9 @@
 
 __m128i test_mm_movm_epi32(__mmask8 __A) {
   // CIR-LABEL: _mm_movm_epi32
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u8i), !cir.vector<!cir.int<s, 1> x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u8i -> !cir.vector<!cir.int<s, 1> x 8>
   // CIR: %{{.*}} = cir.vec.shuffle(%{{.*}}, %{{.*}} : !cir.vector<!cir.int<s, 1> x 8>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!cir.int<s, 1> x 4>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 4>), !cir.vector<!s32i x 4>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 4> -> !cir.vector<!s32i x 4>
 
   // LLVM-LABEL: @test_mm_movm_epi32
   // LLVM: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
@@ -21,8 +21,8 @@ __m128i test_mm_movm_epi32(__mmask8 __A) {
 
 __m256i test_mm256_movm_epi32(__mmask8 __A) {
   // CIR-LABEL: _mm256_movm_epi32
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u8i), !cir.vector<!cir.int<s, 1> x 8>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 8>), !cir.vector<!s32i x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u8i -> !cir.vector<!cir.int<s, 1> x 8>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 8> -> !cir.vector<!s32i x 8>
 
   // LLVM-LABEL: @test_mm256_movm_epi32
   // LLVM: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
@@ -32,8 +32,8 @@ __m256i test_mm256_movm_epi32(__mmask8 __A) {
 
 __m512i test_mm512_movm_epi32(__mmask16 __A) {
   // CIR-LABEL: _mm512_movm_epi32
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u16i), !cir.vector<!cir.int<s, 1> x 16>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 16>), !cir.vector<!s32i x 16>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u16i -> !cir.vector<!cir.int<s, 1> x 16>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 16> -> !cir.vector<!s32i x 16>
 
   // LLVM-LABEL: @test_mm512_movm_epi32
   // LLVM: %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
@@ -43,9 +43,9 @@ __m512i test_mm512_movm_epi32(__mmask16 __A) {
 
 __m128i test_mm_movm_epi64(__mmask8 __A) {
   // CIR-LABEL: _mm_movm_epi64
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u8i), !cir.vector<!cir.int<s, 1> x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u8i -> !cir.vector<!cir.int<s, 1> x 8>
   // CIR: %{{.*}} = cir.vec.shuffle(%{{.*}}, %{{.*}} : !cir.vector<!cir.int<s, 1> x 8>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i] : !cir.vector<!cir.int<s, 1> x 2>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 2>), !cir.vector<!s64i x 2>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 2> -> !cir.vector<!s64i x 2>
 
   // LLVM-LABEL: @test_mm_movm_epi64
   // LLVM: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
@@ -56,9 +56,9 @@ __m128i test_mm_movm_epi64(__mmask8 __A) {
 
 __m256i test_mm256_movm_epi64(__mmask8 __A) {
   // CIR-LABEL: _mm256_movm_epi64
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !u8i), !cir.vector<!cir.int<s, 1> x 8>
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !u8i -> !cir.vector<!cir.int<s, 1> x 8>
   // CIR: %{{.*}} = cir.vec.shuffle(%{{.*}}, %{{.*}} : !cir.vector<!cir.int<s, 1> x 8>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!cir.int<s, 1> x 4>
-  // CIR: %{{.*}} = cir.cast(integral, %{{.*}} : !cir.vector<!cir.int<s, 1> x 4>), !cir.vector<!s64i x 4>
+  // CIR: %{{.*}} = cir.cast integral %{{.*}} : !cir.vector<!cir.int<s, 1> x 4> -> !cir.vector<!s64i x 4>
 
   // LLVM-LABEL: @test_mm256_movm_epi64
   // LLVM: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
@@ -98,7 +98,7 @@ __mmask8 test_mm_movepi64_mask(__m128i __A) {
   // CIR-LABEL: _mm_movepi64_mask
   // CIR: %{{.*}} = cir.vec.cmp(lt, %{{.*}}, %{{.*}}) : !cir.vector<!s64i x 2>, !cir.vector<!cir.int<u, 1> x 2>
   // CIR: %{{.*}} = cir.vec.shuffle(%{{.*}}, %{{.*}} : !cir.vector<!cir.int<u, 1> x 2>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<!cir.int<u, 1> x 8>
-  // CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.vector<!cir.int<u, 1> x 8>), !u8i
+  // CIR: %{{.*}} = cir.cast bitcast %{{.*}} : !cir.vector<!cir.int<u, 1> x 8> -> !u8i
 
   // LLVM-LABEL: @test_mm_movepi64_mask
   // LLVM: [[CMP:%.*]] = icmp slt <2 x i64> %{{.*}}, zeroinitializer
diff --git a/clang/test/CIR/CodeGen/X86/sse-builtins.c b/clang/test/CIR/CodeGen/X86/sse-builtins.c
index 79cb410c3b7b..b44065036438 100644
--- a/clang/test/CIR/CodeGen/X86/sse-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/sse-builtins.c
@@ -36,7 +36,7 @@ void test_mm_sfence(void) {
 __m128 test_mm_undefined_ps(void) {
   // CIR-LABEL: _mm_undefined_ps
   // CIR: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 2>
-  // CIR: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 2>), !cir.vector<!cir.float x 4>
+  // CIR: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 2> -> !cir.vector<!cir.float x 4>
   // CIR: cir.return %{{.*}} : !cir.vector<!cir.float x 4>
 
   // LLVM-LABEL: test_mm_undefined_ps
diff --git a/clang/test/CIR/CodeGen/X86/sse2-builtins.c b/clang/test/CIR/CodeGen/X86/sse2-builtins.c
index efdccc98d1ce..a05ee633a7c2 100644
--- a/clang/test/CIR/CodeGen/X86/sse2-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/sse2-builtins.c
@@ -42,7 +42,7 @@ __m128d test_mm_undefined_pd(void) {
 __m128i test_mm_undefined_si128(void) {
   // CIR-LABEL: _mm_undefined_si128
   // CIR-CHECK: %[[A:.*]] = cir.const #cir.zero : !cir.vector<!cir.double x 2>
-  // CIR-CHECK: %{{.*}} = cir.cast(bitcast, %[[A]] : !cir.vector<!cir.double x 2>), !cir.vector<!s64i x 2>
+  // CIR-CHECK: %{{.*}} = cir.cast bitcast %[[A]] : !cir.vector<!cir.double x 2> -> !cir.vector<!s64i x 2>
   // CIR-CHECK: cir.return %{{.*}} : !cir.vector<!s64i x 2>
 
   // LLVM-CHECK-LABEL: test_mm_undefined_si128
@@ -57,7 +57,7 @@ int test_mm_extract_epi16(__m128i A) {
     
   // CIR-CHECK-LABEL: test_mm_extract_epi16
   // CIR-CHECK %{{.*}} = cir.vec.extract %{{.*}}[%{{.*}} : {{!u32i|!u64i}}] : !cir.vector<!s16i x 8>
-  // CIR-CHECK %{{.*}} = cir.cast(integral, %{{.*}} : !u16i), !s32i
+  // CIR-CHECK %{{.*}} = cir.cast integral %{{.*}} : !u16i -> !s32i
 
   // LLVM-CHECK-LABEL: test_mm_extract_epi16
   // LLVM-CHECK: extractelement <8 x i16> %{{.*}}, {{i32|i64}} 1
diff --git a/clang/test/CIR/CodeGen/X86/sse41-builtins.c b/clang/test/CIR/CodeGen/X86/sse41-builtins.c
index ba8ec065788b..20f78508a2a5 100644
--- a/clang/test/CIR/CodeGen/X86/sse41-builtins.c
+++ b/clang/test/CIR/CodeGen/X86/sse41-builtins.c
@@ -21,7 +21,7 @@
 int test_mm_extract_epi8(__m128i x) {
   // CIR-CHECK-LABEL: test_mm_extract_epi8
   // CIR-CHECK %{{.*}} = cir.vec.extract %{{.*}}[%{{.*}} : {{!u32i|!u64i}}] : !cir.vector<!s8i x 16>
-  // CIR-CHECK %{{.*}} = cir.cast(integral, %{{.*}} : !u8i), !s32i
+  // CIR-CHECK %{{.*}} = cir.cast integral %{{.*}} : !u8i -> !s32i
 
   // LLVM-CHECK-LABEL: test_mm_extract_epi8
   // LLVM-CHECK: extractelement <16 x i8> %{{.*}}, {{i32|i64}} 1
diff --git a/clang/test/CIR/CodeGen/X86/x86_64-xsave.c b/clang/test/CIR/CodeGen/X86/x86_64-xsave.c
index afcd324144ee..86a6c3bdce93 100644
--- a/clang/test/CIR/CodeGen/X86/x86_64-xsave.c
+++ b/clang/test/CIR/CodeGen/X86/x86_64-xsave.c
@@ -61,8 +61,8 @@ void test(void) {
 // CIR-XSAVE: [[tmp_vp_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVE: [[tmp_ULLi_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVE: [[high64_1:%.*]] = cir.shift(right, [[tmp_ULLi_1]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVE: [[high32_1:%.*]] = cir.cast(integral, [[high64_1]] : !u64i), !s32i
-// CIR-XSAVE: [[low32_1:%.*]] = cir.cast(integral, [[tmp_ULLi_1]] : !u64i), !s32i
+// CIR-XSAVE: [[high32_1:%.*]] = cir.cast integral [[high64_1]] : !u64i -> !s32i
+// CIR-XSAVE: [[low32_1:%.*]] = cir.cast integral [[tmp_ULLi_1]] : !u64i -> !s32i
 // CIR-XSAVE: %{{.*}} = cir.llvm.intrinsic "x86.xsave" [[tmp_vp_1]], [[high32_1]], [[low32_1]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVE: [[tmp_vp_1:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -77,8 +77,8 @@ void test(void) {
 // CIR-XSAVE: [[tmp_vp_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVE: [[tmp_ULLi_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVE: [[high64_2:%.*]] = cir.shift(right, [[tmp_ULLi_2]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVE: [[high32_2:%.*]] = cir.cast(integral, [[high64_2]] : !u64i), !s32i
-// CIR-XSAVE: [[low32_2:%.*]] = cir.cast(integral, [[tmp_ULLi_2]] : !u64i), !s32i
+// CIR-XSAVE: [[high32_2:%.*]] = cir.cast integral [[high64_2]] : !u64i -> !s32i
+// CIR-XSAVE: [[low32_2:%.*]] = cir.cast integral [[tmp_ULLi_2]] : !u64i -> !s32i
 // CIR-XSAVE: %{{.*}} = cir.llvm.intrinsic "x86.xsave64" [[tmp_vp_2]], [[high32_2]], [[low32_2]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVE: [[tmp_vp_2:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -93,8 +93,8 @@ void test(void) {
 // CIR-XSAVE: [[tmp_vp_3:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVE: [[tmp_ULLi_3:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVE: [[high64_3:%.*]] = cir.shift(right, [[tmp_ULLi_3]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVE: [[high32_3:%.*]] = cir.cast(integral, [[high64_3]] : !u64i), !s32i
-// CIR-XSAVE: [[low32_3:%.*]] = cir.cast(integral, [[tmp_ULLi_3]] : !u64i), !s32i
+// CIR-XSAVE: [[high32_3:%.*]] = cir.cast integral [[high64_3]] : !u64i -> !s32i
+// CIR-XSAVE: [[low32_3:%.*]] = cir.cast integral [[tmp_ULLi_3]] : !u64i -> !s32i
 // CIR-XSAVE: %{{.*}} = cir.llvm.intrinsic "x86.xrstor" [[tmp_vp_3]], [[high32_3]], [[low32_3]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVE: [[tmp_vp_3:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -109,8 +109,8 @@ void test(void) {
 // CIR-XSAVE: [[tmp_vp_4:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVE: [[tmp_ULLi_4:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVE: [[high64_4:%.*]] = cir.shift(right, [[tmp_ULLi_4]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVE: [[high32_4:%.*]] = cir.cast(integral, [[high64_4]] : !u64i), !s32i
-// CIR-XSAVE: [[low32_4:%.*]] = cir.cast(integral, [[tmp_ULLi_4]] : !u64i), !s32i
+// CIR-XSAVE: [[high32_4:%.*]] = cir.cast integral [[high64_4]] : !u64i -> !s32i
+// CIR-XSAVE: [[low32_4:%.*]] = cir.cast integral [[tmp_ULLi_4]] : !u64i -> !s32i
 // CIR-XSAVE: %{{.*}} = cir.llvm.intrinsic "x86.xrstor64" [[tmp_vp_4]], [[high32_4]], [[low32_4]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVE: [[tmp_vp_4:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -143,8 +143,8 @@ void test(void) {
 // CIR-XSAVEOPT: [[tmp_vp_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVEOPT: [[tmp_ULLi_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVEOPT: [[high64_1:%.*]] = cir.shift(right, [[tmp_ULLi_1]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVEOPT: [[high32_1:%.*]] = cir.cast(integral, [[high64_1]] : !u64i), !s32i
-// CIR-XSAVEOPT: [[low32_1:%.*]] = cir.cast(integral, [[tmp_ULLi_1]] : !u64i), !s32i
+// CIR-XSAVEOPT: [[high32_1:%.*]] = cir.cast integral [[high64_1]] : !u64i -> !s32i
+// CIR-XSAVEOPT: [[low32_1:%.*]] = cir.cast integral [[tmp_ULLi_1]] : !u64i -> !s32i
 // CIR-XSAVEOPT: %{{.*}} = cir.llvm.intrinsic "x86.xsaveopt" [[tmp_vp_1]], [[high32_1]], [[low32_1]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVEOPT: [[tmp_vp_1:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -158,8 +158,8 @@ void test(void) {
 // CIR-XSAVEOPT: [[tmp_vp_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVEOPT: [[tmp_ULLi_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVEOPT: [[high64_2:%.*]] = cir.shift(right, [[tmp_ULLi_2]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVEOPT: [[high32_2:%.*]] = cir.cast(integral, [[high64_2]] : !u64i), !s32i
-// CIR-XSAVEOPT: [[low32_2:%.*]] = cir.cast(integral, [[tmp_ULLi_2]] : !u64i), !s32i
+// CIR-XSAVEOPT: [[high32_2:%.*]] = cir.cast integral [[high64_2]] : !u64i -> !s32i
+// CIR-XSAVEOPT: [[low32_2:%.*]] = cir.cast integral [[tmp_ULLi_2]] : !u64i -> !s32i
 // CIR-XSAVEOPT: %{{.*}} = cir.llvm.intrinsic "x86.xsaveopt64" [[tmp_vp_2]], [[high32_2]], [[low32_2]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVEOPT: [[tmp_vp_2:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -183,8 +183,8 @@ void test(void) {
 // CIR-XSAVEC: [[tmp_vp_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVEC: [[tmp_ULLi_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVEC: [[high64_1:%.*]] = cir.shift(right, [[tmp_ULLi_1]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVEC: [[high32_1:%.*]] = cir.cast(integral, [[high64_1]] : !u64i), !s32i
-// CIR-XSAVEC: [[low32_1:%.*]] = cir.cast(integral, [[tmp_ULLi_1]] : !u64i), !s32i
+// CIR-XSAVEC: [[high32_1:%.*]] = cir.cast integral [[high64_1]] : !u64i -> !s32i
+// CIR-XSAVEC: [[low32_1:%.*]] = cir.cast integral [[tmp_ULLi_1]] : !u64i -> !s32i
 // CIR-XSAVEC: %{{.*}} = cir.llvm.intrinsic "x86.xsavec" [[tmp_vp_1]], [[high32_1]], [[low32_1]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVEC: [[tmp_vp_1:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -199,8 +199,8 @@ void test(void) {
 // CIR-XSAVEC: [[tmp_vp_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVEC: [[tmp_ULLi_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVEC: [[high64_2:%.*]] = cir.shift(right, [[tmp_ULLi_2]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVEC: [[high32_2:%.*]] = cir.cast(integral, [[high64_2]] : !u64i), !s32i
-// CIR-XSAVEC: [[low32_2:%.*]] = cir.cast(integral, [[tmp_ULLi_2]] : !u64i), !s32i
+// CIR-XSAVEC: [[high32_2:%.*]] = cir.cast integral [[high64_2]] : !u64i -> !s32i
+// CIR-XSAVEC: [[low32_2:%.*]] = cir.cast integral [[tmp_ULLi_2]] : !u64i -> !s32i
 // CIR-XSAVEC: %{{.*}} = cir.llvm.intrinsic "x86.xsavec64" [[tmp_vp_2]], [[high32_2]], [[low32_2]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVEC: [[tmp_vp_2:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -224,8 +224,8 @@ void test(void) {
 // CIR-XSAVES: [[tmp_vp_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVES: [[tmp_ULLi_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVES: [[high64_1:%.*]] = cir.shift(right, [[tmp_ULLi_1]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVES: [[high32_1:%.*]] = cir.cast(integral, [[high64_1]] : !u64i), !s32i
-// CIR-XSAVES: [[low32_1:%.*]] = cir.cast(integral, [[tmp_ULLi_1]] : !u64i), !s32i
+// CIR-XSAVES: [[high32_1:%.*]] = cir.cast integral [[high64_1]] : !u64i -> !s32i
+// CIR-XSAVES: [[low32_1:%.*]] = cir.cast integral [[tmp_ULLi_1]] : !u64i -> !s32i
 // CIR-XSAVES: %{{.*}} = cir.llvm.intrinsic "x86.xsaves" [[tmp_vp_1]], [[high32_1]], [[low32_1]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVES: [[tmp_vp_1:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -240,8 +240,8 @@ void test(void) {
 // CIR-XSAVES: [[tmp_vp_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVES: [[tmp_ULLi_2:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVES: [[high64_2:%.*]] = cir.shift(right, [[tmp_ULLi_2]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVES: [[high32_2:%.*]] = cir.cast(integral, [[high64_2]] : !u64i), !s32i
-// CIR-XSAVES: [[low32_2:%.*]] = cir.cast(integral, [[tmp_ULLi_2]] : !u64i), !s32i
+// CIR-XSAVES: [[high32_2:%.*]] = cir.cast integral [[high64_2]] : !u64i -> !s32i
+// CIR-XSAVES: [[low32_2:%.*]] = cir.cast integral [[tmp_ULLi_2]] : !u64i -> !s32i
 // CIR-XSAVES: %{{.*}} = cir.llvm.intrinsic "x86.xsaves64" [[tmp_vp_2]], [[high32_2]], [[low32_2]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVES: [[tmp_vp_2:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -256,8 +256,8 @@ void test(void) {
 // CIR-XSAVES: [[tmp_vp_3:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVES: [[tmp_ULLi_3:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVES: [[high64_3:%.*]] = cir.shift(right, [[tmp_ULLi_3]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVES: [[high32_3:%.*]] = cir.cast(integral, [[high64_3]] : !u64i), !s32i
-// CIR-XSAVES: [[low32_3:%.*]] = cir.cast(integral, [[tmp_ULLi_3]] : !u64i), !s32i
+// CIR-XSAVES: [[high32_3:%.*]] = cir.cast integral [[high64_3]] : !u64i -> !s32i
+// CIR-XSAVES: [[low32_3:%.*]] = cir.cast integral [[tmp_ULLi_3]] : !u64i -> !s32i
 // CIR-XSAVES: %{{.*}} = cir.llvm.intrinsic "x86.xrstors" [[tmp_vp_3]], [[high32_3]], [[low32_3]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVES: [[tmp_vp_3:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -272,8 +272,8 @@ void test(void) {
 // CIR-XSAVES: [[tmp_vp_4:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR-XSAVES: [[tmp_ULLi_4:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSAVES: [[high64_4:%.*]] = cir.shift(right, [[tmp_ULLi_4]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSAVES: [[high32_4:%.*]] = cir.cast(integral, [[high64_4]] : !u64i), !s32i
-// CIR-XSAVES: [[low32_4:%.*]] = cir.cast(integral, [[tmp_ULLi_4]] : !u64i), !s32i
+// CIR-XSAVES: [[high32_4:%.*]] = cir.cast integral [[high64_4]] : !u64i -> !s32i
+// CIR-XSAVES: [[low32_4:%.*]] = cir.cast integral [[tmp_ULLi_4]] : !u64i -> !s32i
 // CIR-XSAVES: %{{.*}} = cir.llvm.intrinsic "x86.xrstors64" [[tmp_vp_4]], [[high32_4]], [[low32_4]] : (!cir.ptr<!void>, !s32i, !s32i) -> !void
 
 // LLVM-XSAVES: [[tmp_vp_4:%.*]] = load ptr, ptr %{{.*}}, align 8
@@ -320,8 +320,8 @@ void test(void) {
 // CIR-XSETBV: [[tmp_Ui_1:%.*]] = cir.load align(4) %{{.*}} : !cir.ptr<!u32i>, !u32i
 // CIR-XSETBV: [[tmp_ULLi_1:%.*]] = cir.load align(8) %{{.*}} : !cir.ptr<!u64i>, !u64i
 // CIR-XSETBV: [[high64_1:%.*]] = cir.shift(right, [[tmp_ULLi_1]] : !u64i, %{{.*}} : !u64i) -> !u64i
-// CIR-XSETBV: [[high32_1:%.*]] = cir.cast(integral, [[high64_1]] : !u64i), !s32i
-// CIR-XSETBV: [[low32_1:%.*]] = cir.cast(integral, [[tmp_ULLi_1]] : !u64i), !s32i
+// CIR-XSETBV: [[high32_1:%.*]] = cir.cast integral [[high64_1]] : !u64i -> !s32i
+// CIR-XSETBV: [[low32_1:%.*]] = cir.cast integral [[tmp_ULLi_1]] : !u64i -> !s32i
 // CIR-XSETBV: %{{.*}} = cir.llvm.intrinsic "x86.xsetbv" [[tmp_Ui_1]], [[high32_1]], [[low32_1]] : (!u32i, !s32i, !s32i) -> !void
 
 // LLVM-XSETBV: [[tmp_Ui_1:%.*]] = load i32, ptr %{{.*}}, align 4
diff --git a/clang/test/CIR/CodeGen/aapcs-volatile-bitfields.c b/clang/test/CIR/CodeGen/aapcs-volatile-bitfields.c
index dbc65c5856ef..8334158ef756 100644
--- a/clang/test/CIR/CodeGen/aapcs-volatile-bitfields.c
+++ b/clang/test/CIR/CodeGen/aapcs-volatile-bitfields.c
@@ -86,7 +86,7 @@ int check_load(st1 *s1) {
 // CIR:    [[LOAD:%.*]] = cir.load align(8) {{.*}} : !cir.ptr<!cir.ptr<!rec_st1>>, !cir.ptr<!rec_st1>
 // CIR:    [[MEMBER:%.*]] = cir.get_member [[LOAD]][0] {name = "b"} : !cir.ptr<!rec_st1> -> !cir.ptr<!u16i>
 // CIR:    [[BITFI:%.*]] = cir.get_bitfield align(4) (#bfi_b, [[MEMBER]] {is_volatile} : !cir.ptr<!u16i>) -> !u32i
-// CIR:    [[CAST:%.*]] = cir.cast(integral, [[BITFI]] : !u32i), !s32i
+// CIR:    [[CAST:%.*]] = cir.cast integral [[BITFI]] : !u32i -> !s32i
 // CIR:    cir.store [[CAST]], [[RETVAL:%.*]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[RET:%.*]] = cir.load [[RETVAL]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.return [[RET]] : !s32i
@@ -118,7 +118,7 @@ int check_load_exception(st3 *s3) {
 // CIR:    [[LOAD:%.*]] = cir.load align(8) {{.*}} : !cir.ptr<!cir.ptr<!rec_st3>>, !cir.ptr<!rec_st3>
 // CIR:    [[MEMBER:%.*]] = cir.get_member [[LOAD]][2] {name = "b"} : !cir.ptr<!rec_st3> -> !cir.ptr<!u8i>
 // CIR:    [[BITFI:%.*]] = cir.get_bitfield align(4) (#bfi_b1, [[MEMBER]] {is_volatile} : !cir.ptr<!u8i>) -> !u32i
-// CIR:    [[CAST:%.*]] = cir.cast(integral, [[BITFI]] : !u32i), !s32i
+// CIR:    [[CAST:%.*]] = cir.cast integral [[BITFI]] : !u32i -> !s32i
 // CIR:    cir.store [[CAST]], [[RETVAL:%.*]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[RET:%.*]] = cir.load [[RETVAL]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.return [[RET]] : !s32i
@@ -180,7 +180,7 @@ void check_store(st2 *s2) {
 
 // CIR:  cir.func dso_local @check_store
 // CIR:    [[CONST:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR:    [[CAST:%.*]] = cir.cast(integral, [[CONST]] : !s32i), !s16i
+// CIR:    [[CAST:%.*]] = cir.cast integral [[CONST]] : !s32i -> !s16i
 // CIR:    [[LOAD:%.*]] = cir.load align(8) {{.*}} : !cir.ptr<!cir.ptr<!rec_st2>>, !cir.ptr<!rec_st2>
 // CIR:    [[MEMBER:%.*]] = cir.get_member [[LOAD]][0] {name = "a"} : !cir.ptr<!rec_st2> -> !cir.ptr<!u32i>
 // CIR:    [[SETBF:%.*]] = cir.set_bitfield align(8) (#bfi_a, [[MEMBER]] : !cir.ptr<!u32i>, [[CAST]] : !s16i) {is_volatile} -> !s16i
@@ -211,7 +211,7 @@ void check_store_exception(st3 *s3) {
 
 // CIR:  cir.func dso_local @check_store_exception
 // CIR:    [[CONST:%.*]] = cir.const #cir.int<2> : !s32i
-// CIR:    [[CAST:%.*]] = cir.cast(integral, [[CONST]] : !s32i), !u32i
+// CIR:    [[CAST:%.*]] = cir.cast integral [[CONST]] : !s32i -> !u32i
 // CIR:    [[LOAD:%.*]] = cir.load align(8) {{.*}} : !cir.ptr<!cir.ptr<!rec_st3>>, !cir.ptr<!rec_st3>
 // CIR:    [[MEMBER:%.*]] = cir.get_member [[LOAD]][2] {name = "b"} : !cir.ptr<!rec_st3> -> !cir.ptr<!u8i>
 // CIR:    [[SETBF:%.*]] = cir.set_bitfield align(4) (#bfi_b1, [[MEMBER]] : !cir.ptr<!u8i>, [[CAST]] : !u32i) {is_volatile} -> !u32i
@@ -263,7 +263,7 @@ void check_store_second_member (st4 *s4) {
 
 // CIR:  cir.func dso_local @check_store_second_member
 // CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
-// CIR:    [[CAST:%.*]] = cir.cast(integral, [[ONE]] : !s32i), !u64i
+// CIR:    [[CAST:%.*]] = cir.cast integral [[ONE]] : !s32i -> !u64i
 // CIR:    [[LOAD:%.*]] = cir.load align(8) {{.*}} : !cir.ptr<!cir.ptr<!rec_st4>>, !cir.ptr<!rec_st4>
 // CIR:    [[MEMBER:%.*]] = cir.get_member [[LOAD]][2] {name = "b"} : !cir.ptr<!rec_st4> -> !cir.ptr<!u16i>
 // CIR:    cir.set_bitfield align(8) (#bfi_b2, [[MEMBER]] : !cir.ptr<!u16i>, [[CAST]] : !u64i) {is_volatile} -> !u64i
diff --git a/clang/test/CIR/CodeGen/abstract-cond.c b/clang/test/CIR/CodeGen/abstract-cond.c
index 1da85623bf10..3c2ef4b2d1ae 100644
--- a/clang/test/CIR/CodeGen/abstract-cond.c
+++ b/clang/test/CIR/CodeGen/abstract-cond.c
@@ -16,7 +16,7 @@ int f6(int a0, struct s6 a1, struct s6 a2) {
 // CIR:  cir.scope {
 // CIR:    %[[TMP:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["ref.tmp0"]
 // CIR:    %[[LOAD_A0:.*]] = cir.load{{.*}} %[[A0]] : !cir.ptr<!s32i>, !s32i
-// CIR:    %[[COND:.*]] = cir.cast(int_to_bool, %[[LOAD_A0]] : !s32i), !cir.bool
+// 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>
 // CIR:    } else {
diff --git a/clang/test/CIR/CodeGen/address-space-conversion.cpp b/clang/test/CIR/CodeGen/address-space-conversion.cpp
index ab01d17a20b7..ce26ef69ebf8 100644
--- a/clang/test/CIR/CodeGen/address-space-conversion.cpp
+++ b/clang/test/CIR/CodeGen/address-space-conversion.cpp
@@ -15,7 +15,7 @@ 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-NEXT: %[[#CAST:]] = cir.cast(address_space, %[[#PTR1]] : !cir.ptr<!s32i, addrspace(target<1>)>), !cir.ptr<!s32i, addrspace(target<2>)>
+  // 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>)>>
 
   // LLVM:      %[[#PTR1:]] = load ptr addrspace(1), ptr %{{[0-9]+}}, align 8
@@ -32,7 +32,7 @@ void test_ref() {
   // 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: %[[#CAST:]] = cir.cast(address_space, %[[#REF1]] : !cir.ptr<!s32i, addrspace(target<1>)>), !cir.ptr<!s32i, addrspace(target<2>)>
+  // 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>)>>
 
   // LLVM:      %[[#DEREF:]] = load ptr addrspace(1), ptr %{{[0-9]+}}, align 8
diff --git a/clang/test/CIR/CodeGen/agg-init.cpp b/clang/test/CIR/CodeGen/agg-init.cpp
index a8fd63ade305..61d7df8bac7e 100644
--- a/clang/test/CIR/CodeGen/agg-init.cpp
+++ b/clang/test/CIR/CodeGen/agg-init.cpp
@@ -55,7 +55,7 @@ void yo() {
 // CHECK:   %4 = cir.const #cir.int<1000066001> : !u32i
 // CHECK:   cir.store{{.*}} %4, %3 : !u32i, !cir.ptr<!u32i>
 // CHECK:   %5 = cir.get_member %1[1] {name = "next"} : !cir.ptr<!rec_Yo> -> !cir.ptr<!cir.ptr<!void>>
-// CHECK:   %6 = cir.cast(bitcast, %0 : !cir.ptr<!rec_Yo>), !cir.ptr<!void>
+// CHECK:   %6 = cir.cast bitcast %0 : !cir.ptr<!rec_Yo> -> !cir.ptr<!void>
 // CHECK:   cir.store{{.*}} %6, %5 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
 // CHECK:   %7 = cir.get_member %1[2] {name = "createFlags"} : !cir.ptr<!rec_Yo> -> !cir.ptr<!u64i>
 // CHECK:   %8 = cir.const #cir.int<0> : !u64i
diff --git a/clang/test/CIR/CodeGen/applearm64-array-cookies.cpp b/clang/test/CIR/CodeGen/applearm64-array-cookies.cpp
index 106d3743596d..13a1e5475770 100644
--- a/clang/test/CIR/CodeGen/applearm64-array-cookies.cpp
+++ b/clang/test/CIR/CodeGen/applearm64-array-cookies.cpp
@@ -15,14 +15,14 @@ void t_constant_size_nontrivial() {
 // CHECK:    %[[#SIZE_WITHOUT_COOKIE:]] = cir.const #cir.int<3> : !u64i
 // CHECK:    %[[#ALLOCATION_SIZE:]] = cir.const #cir.int<19> : !u64i
 // CHECK:    %[[#ALLOC_PTR:]] = cir.call @_Znam(%[[#ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %[[#COOKIE_PTR:]] = cir.cast(bitcast, %[[#ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CHECK:    %[[#COOKIE_PTR:]] = cir.cast bitcast %[[#ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CHECK:    %[[#ELEMENT_SIZE:]] = cir.const #cir.int<1> : !u64i
 // CHECK:    cir.store{{.*}} %[[#ELEMENT_SIZE]], %[[#COOKIE_PTR]] : !u64i, !cir.ptr<!u64i>
 // CHECK:    %[[#SECOND_COOKIE_OFFSET:]] = cir.const #cir.int<1> : !s32i
 // CHECK:    %[[#COOKIE_PTR2:]] = cir.ptr_stride %[[#COOKIE_PTR]], %[[#SECOND_COOKIE_OFFSET]] : (!cir.ptr<!u64i>, !s32i) -> !cir.ptr<!u64i>
 // CHECK:    cir.store{{.*}} %[[#NUM_ELEMENTS]], %[[#COOKIE_PTR2]] : !u64i, !cir.ptr<!u64i>
 // CHECK:    %[[#COOKIE_SIZE:]] = cir.const #cir.int<16> : !s32i
-// CHECK:    %[[#ALLOC_AS_I8:]] = cir.cast(bitcast, %[[#ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u8i>
+// CHECK:    %[[#ALLOC_AS_I8:]] = cir.cast bitcast %[[#ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // CHECK:    cir.ptr_stride %[[#ALLOC_AS_I8]], %[[#COOKIE_SIZE]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
 
 class D {
@@ -43,12 +43,12 @@ void t_constant_size_nontrivial2() {
 // CHECK:    %[[#SIZE_WITHOUT_COOKIE:]] = cir.const #cir.int<12> : !u64i
 // CHECK:    %[[#ALLOCATION_SIZE:]] = cir.const #cir.int<28> : !u64i
 // CHECK:    %[[#ALLOC_PTR:]] = cir.call @_Znam(%[[#ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %[[#COOKIE_PTR:]] = cir.cast(bitcast, %[[#ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CHECK:    %[[#COOKIE_PTR:]] = cir.cast bitcast %[[#ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CHECK:    %[[#ELEMENT_SIZE:]] = cir.const #cir.int<4> : !u64i
 // CHECK:    cir.store{{.*}} %[[#ELEMENT_SIZE]], %[[#COOKIE_PTR]] : !u64i, !cir.ptr<!u64i>
 // CHECK:    %[[#SECOND_COOKIE_OFFSET:]] = cir.const #cir.int<1> : !s32i
 // CHECK:    %[[#COOKIE_PTR2:]] = cir.ptr_stride %[[#COOKIE_PTR]], %[[#SECOND_COOKIE_OFFSET]] : (!cir.ptr<!u64i>, !s32i) -> !cir.ptr<!u64i>
 // CHECK:    cir.store{{.*}} %[[#NUM_ELEMENTS]], %[[#COOKIE_PTR2]] : !u64i, !cir.ptr<!u64i>
 // CHECK:    %[[#COOKIE_SIZE:]] = cir.const #cir.int<16> : !s32i
-// CHECK:    %[[#ALLOC_AS_I8:]] = cir.cast(bitcast, %[[#ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u8i>
+// CHECK:    %[[#ALLOC_AS_I8:]] = cir.cast bitcast %[[#ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // CHECK:    cir.ptr_stride %[[#ALLOC_AS_I8]], %[[#COOKIE_SIZE]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGen/array-init-destroy.cpp b/clang/test/CIR/CodeGen/array-init-destroy.cpp
index 7462766afef9..a4fe0c6a7eeb 100644
--- a/clang/test/CIR/CodeGen/array-init-destroy.cpp
+++ b/clang/test/CIR/CodeGen/array-init-destroy.cpp
@@ -40,7 +40,7 @@ void x() {
 // AFTER: cir.func dso_local @_Z1xv()
 // AFTER: %[[ArrayAddr0:.*]] = cir.alloca !cir.array<!rec_xpto x 2>
 // AFTER: %[[ConstTwo:.*]] = cir.const #cir.int<2> : !u64i
-// AFTER: %[[ArrayBegin:.*]] = cir.cast(array_to_ptrdecay, %[[ArrayAddr0]] : !cir.ptr<!cir.array<!rec_xpto x 2>>), !cir.ptr<!rec_xpto>
+// AFTER: %[[ArrayBegin:.*]] = cir.cast array_to_ptrdecay %[[ArrayAddr0]] : !cir.ptr<!cir.array<!rec_xpto x 2>> -> !cir.ptr<!rec_xpto>
 // AFTER: %[[ArrayPastEnd:.*]] = cir.ptr_stride %[[ArrayBegin]], %[[ConstTwo]] : (!cir.ptr<!rec_xpto>, !u64i) -> !cir.ptr<!rec_xpto>
 // AFTER: %[[TmpIdx:.*]] = cir.alloca !cir.ptr<!rec_xpto>, !cir.ptr<!cir.ptr<!rec_xpto>>, ["__array_idx"] {alignment = 1 : i64}
 // AFTER: cir.store %[[ArrayBegin]], %[[TmpIdx]] : !cir.ptr<!rec_xpto>, !cir.ptr<!cir.ptr<!rec_xpto>>
@@ -57,7 +57,7 @@ void x() {
 // AFTER:   cir.condition(%[[ExitCond]])
 // AFTER: }
 // AFTER: %[[ConstOne:.*]] = cir.const #cir.int<1> : !u64i
-// AFTER: %[[ArrayBegin:.*]] = cir.cast(array_to_ptrdecay, %[[ArrayAddr0]] : !cir.ptr<!cir.array<!rec_xpto x 2>>), !cir.ptr<!rec_xpto>
+// AFTER: %[[ArrayBegin:.*]] = cir.cast array_to_ptrdecay %[[ArrayAddr0]] : !cir.ptr<!cir.array<!rec_xpto x 2>> -> !cir.ptr<!rec_xpto>
 // AFTER: %[[ArrayEnd:.*]] = cir.ptr_stride %[[ArrayBegin]], %[[ConstOne]] : (!cir.ptr<!rec_xpto>, !u64i) -> !cir.ptr<!rec_xpto>
 // AFTER: %[[TmpIdx:.*]] = cir.alloca !cir.ptr<!rec_xpto>, !cir.ptr<!cir.ptr<!rec_xpto>>, ["__array_idx"] {alignment = 1 : i64}
 // AFTER: cir.store %[[ArrayEnd]], %[[TmpIdx]] : !cir.ptr<!rec_xpto>, !cir.ptr<!cir.ptr<!rec_xpto>>
diff --git a/clang/test/CIR/CodeGen/array-init.c b/clang/test/CIR/CodeGen/array-init.c
index e712e693942c..e5087bd796c1 100644
--- a/clang/test/CIR/CodeGen/array-init.c
+++ b/clang/test/CIR/CodeGen/array-init.c
@@ -65,7 +65,7 @@ void buz(int x) {
 // CIR-NEXT: cir.store{{.*}} [[XA_VAL]], [[A_STORAGE0]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[B_STORAGE0:%.*]] = cir.get_member [[FI_EL]][1] {name = "b"} : !cir.ptr<!rec_T> -> !cir.ptr<!s64i>
 // CIR-NEXT: [[XB_VAL:%.*]] = cir.load{{.*}} [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT: [[XB_CASTED:%.*]] = cir.cast(integral, [[XB_VAL]] : !s32i), !s64i
+// CIR-NEXT: [[XB_CASTED:%.*]] = cir.cast integral [[XB_VAL]] : !s32i -> !s64i
 // CIR-NEXT: cir.store{{.*}} [[XB_CASTED]], [[B_STORAGE0]] : !s64i, !cir.ptr<!s64i>
 // CIR-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
 // CIR-NEXT: [[SE_EL:%.*]] = cir.get_element [[ARR]][[[ONE]]] : (!cir.ptr<!cir.array<!rec_T x 2>>, !s64i) -> !cir.ptr<!rec_T>
@@ -74,7 +74,7 @@ void buz(int x) {
 // CIR-NEXT: cir.store{{.*}} [[A1_ZERO]], [[A_STORAGE1]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[B_STORAGE1:%.*]] = cir.get_member [[SE_EL]][1] {name = "b"} : !cir.ptr<!rec_T> -> !cir.ptr<!s64i>
 // CIR-NEXT: [[B1_ZERO:%.*]] = cir.const #cir.int<0> : !s32i
-// CIR-NEXT: [[B1_CASTED:%.*]] = cir.cast(integral, [[B1_ZERO]] : !s32i), !s64i
+// CIR-NEXT: [[B1_CASTED:%.*]] = cir.cast integral [[B1_ZERO]] : !s32i -> !s64i
 // CIR-NEXT: cir.store{{.*}} [[B1_CASTED]], [[B_STORAGE1]] : !s64i, !cir.ptr<!s64i>
 // CIR-NEXT: cir.return
 
diff --git a/clang/test/CIR/CodeGen/array-init.cpp b/clang/test/CIR/CodeGen/array-init.cpp
index 5fa381843768..8a2bb223e92d 100644
--- a/clang/test/CIR/CodeGen/array-init.cpp
+++ b/clang/test/CIR/CodeGen/array-init.cpp
@@ -19,7 +19,7 @@ void foo() {
 // CHECK: %[[VAL_3:.*]] = cir.call @_Z3barv() : () -> !s32i
 // CHECK: cir.store{{.*}} %[[VAL_3]], %[[VAL_2]] : !s32i, !cir.ptr<!s32i>
 // CHECK: %[[VAL_4:.*]] = cir.get_member %[[VAL_0]][1] {name = "b"} : !cir.ptr<!rec_A> -> !cir.ptr<!cir.array<!s32i x 2>>
-// CHECK: %[[VAL_5:.*]] = cir.cast(array_to_ptrdecay, %[[VAL_4]] : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!s32i>
+// CHECK: %[[VAL_5:.*]] = cir.cast array_to_ptrdecay %[[VAL_4]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
 // CHECK: cir.store{{.*}} %[[VAL_5]], %[[VAL_1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CHECK: %[[VAL_6:.*]] = cir.const #cir.int<2> : !s64i
 // CHECK: %[[VAL_7:.*]] = cir.get_element %[[VAL_4]][%[[VAL_6]]] : (!cir.ptr<!cir.array<!s32i x 2>>, !s64i) -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/array-new-init.cpp b/clang/test/CIR/CodeGen/array-new-init.cpp
index cebe9d5a4415..791260f2c52e 100644
--- a/clang/test/CIR/CodeGen/array-new-init.cpp
+++ b/clang/test/CIR/CodeGen/array-new-init.cpp
@@ -16,13 +16,13 @@ void t_new_constant_size_constructor() {
 // BEFORE:    %[[SIZE_WITHOUT_COOKIE:.*]] = cir.const #cir.int<3> : !u64i
 // BEFORE:    %[[ALLOC_SIZE:.*]] = cir.const #cir.int<11> : !u64i
 // BEFORE:    %[[ALLOC_PTR:.*]] = cir.call @_Znam(%[[ALLOC_SIZE]])
-// BEFORE:    %[[COOKIE_PTR:.*]] = cir.cast(bitcast, %[[ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u64i>
+// BEFORE:    %[[COOKIE_PTR:.*]] = cir.cast bitcast %[[ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // BEFORE:    cir.store{{.*}} %[[NUM_ELEMENTS]], %[[COOKIE_PTR]] : !u64i, !cir.ptr<!u64i>
-// BEFORE:    %[[PTR_AS_U8:.*]] = cir.cast(bitcast, %[[ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u8i>
+// BEFORE:    %[[PTR_AS_U8:.*]] = cir.cast bitcast %[[ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // BEFORE:    %[[OFFSET:.*]] = cir.const #cir.int<8> : !s32i
 // BEFORE:    %[[OBJ_PTR:.*]] = cir.ptr_stride %[[PTR_AS_U8]], %[[OFFSET]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
-// BEFORE:    %[[OBJ_ELEM_PTR:.*]] = cir.cast(bitcast, %[[OBJ_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!rec_E>
-// BEFORE:    %[[OBJ_ARRAY_PTR:.*]] = cir.cast(bitcast, %[[OBJ_ELEM_PTR]] : !cir.ptr<!rec_E>), !cir.ptr<!cir.array<!rec_E x 3>>
+// BEFORE:    %[[OBJ_ELEM_PTR:.*]] = cir.cast bitcast %[[OBJ_PTR]] : !cir.ptr<!u8i> -> !cir.ptr<!rec_E>
+// BEFORE:    %[[OBJ_ARRAY_PTR:.*]] = cir.cast bitcast %[[OBJ_ELEM_PTR]] : !cir.ptr<!rec_E> -> !cir.ptr<!cir.array<!rec_E x 3>>
 // BEFORE:    cir.array.ctor(%[[OBJ_ARRAY_PTR]] : !cir.ptr<!cir.array<!rec_E x 3>>) {
 // BEFORE:    ^bb0(%arg0: !cir.ptr<!rec_E>
 // BEFORE:      cir.call @_ZN1EC1Ev(%arg0) : (!cir.ptr<!rec_E>) -> ()
@@ -34,15 +34,15 @@ void t_new_constant_size_constructor() {
 // AFTER:    %[[SIZE_WITHOUT_COOKIE:.*]] = cir.const #cir.int<3> : !u64i
 // AFTER:    %[[ALLOC_SIZE:.*]] = cir.const #cir.int<11> : !u64i
 // AFTER:    %[[ALLOC_PTR:.*]] = cir.call @_Znam(%[[ALLOC_SIZE]])
-// AFTER:    %[[COOKIE_PTR:.*]] = cir.cast(bitcast, %[[ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u64i>
+// AFTER:    %[[COOKIE_PTR:.*]] = cir.cast bitcast %[[ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // AFTER:    cir.store{{.*}} %[[NUM_ELEMENTS]], %[[COOKIE_PTR]] : !u64i, !cir.ptr<!u64i>
-// AFTER:    %[[PTR_AS_U8:.*]] = cir.cast(bitcast, %[[ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!u8i>
+// AFTER:    %[[PTR_AS_U8:.*]] = cir.cast bitcast %[[ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // AFTER:    %[[OFFSET:.*]] = cir.const #cir.int<8> : !s32i
 // AFTER:    %[[OBJ_PTR:.*]] = cir.ptr_stride %[[PTR_AS_U8]], %[[OFFSET]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
-// AFTER:    %[[OBJ_ELEM_PTR:.*]] = cir.cast(bitcast, %[[OBJ_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!rec_E>
-// AFTER:    %[[OBJ_ARRAY_PTR:.*]] = cir.cast(bitcast, %[[OBJ_ELEM_PTR]] : !cir.ptr<!rec_E>), !cir.ptr<!cir.array<!rec_E x 3>>
+// AFTER:    %[[OBJ_ELEM_PTR:.*]] = cir.cast bitcast %[[OBJ_PTR]] : !cir.ptr<!u8i> -> !cir.ptr<!rec_E>
+// AFTER:    %[[OBJ_ARRAY_PTR:.*]] = cir.cast bitcast %[[OBJ_ELEM_PTR]] : !cir.ptr<!rec_E> -> !cir.ptr<!cir.array<!rec_E x 3>>
 // AFTER:    %[[NUM_ELEMENTS2:.*]] = cir.const #cir.int<3> : !u64i
-// AFTER:    %[[ELEM_PTR:.*]] = cir.cast(array_to_ptrdecay, %10 : !cir.ptr<!cir.array<!rec_E x 3>>), !cir.ptr<!rec_E>
+// AFTER:    %[[ELEM_PTR:.*]] = cir.cast array_to_ptrdecay %10 : !cir.ptr<!cir.array<!rec_E x 3>> -> !cir.ptr<!rec_E>
 // AFTER:    %[[END_PTR:.*]] = cir.ptr_stride %[[ELEM_PTR]], %[[NUM_ELEMENTS2]] : (!cir.ptr<!rec_E>, !u64i) -> !cir.ptr<!rec_E>
 // AFTER:    %[[CUR_ELEM_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>, ["__array_idx"] {alignment = 1 : i64}
 // AFTER:    cir.store{{.*}} %[[ELEM_PTR]], %[[CUR_ELEM_ALLOCA]] : !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>
diff --git a/clang/test/CIR/CodeGen/array.cpp b/clang/test/CIR/CodeGen/array.cpp
index 36d5f7aaf048..5fa3b09dd1ce 100644
--- a/clang/test/CIR/CodeGen/array.cpp
+++ b/clang/test/CIR/CodeGen/array.cpp
@@ -42,7 +42,7 @@ void local_stringlit() {
 // CHECK: cir.func dso_local @_Z15local_stringlitv()
 // CHECK-NEXT:  %0 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["s", init] {alignment = 8 : i64}
 // CHECK-NEXT:  %1 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 8>>
-// CHECK-NEXT:  %2 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s8i x 8>>), !cir.ptr<!s8i>
+// CHECK-NEXT:  %2 = cir.cast array_to_ptrdecay %1 : !cir.ptr<!cir.array<!s8i x 8>> -> !cir.ptr<!s8i>
 // CHECK-NEXT:  cir.store{{.*}} %2, %0 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 
 int multidim(int i, int j) {
diff --git a/clang/test/CIR/CodeGen/assign-operator.cpp b/clang/test/CIR/CodeGen/assign-operator.cpp
index e080ab7e84c1..b6f436da07cb 100644
--- a/clang/test/CIR/CodeGen/assign-operator.cpp
+++ b/clang/test/CIR/CodeGen/assign-operator.cpp
@@ -80,7 +80,7 @@ int main() {
 // CHECK:     cir.scope {
 // CHECK:       %3 = cir.alloca !rec_String, !cir.ptr<!rec_String>, ["s", init] {alignment = 8 : i64}
 // CHECK:       %4 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
-// CHECK:       %5 = cir.cast(array_to_ptrdecay, %4 : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
+// CHECK:       %5 = cir.cast array_to_ptrdecay %4 : !cir.ptr<!cir.array<!s8i x 3>> -> !cir.ptr<!s8i>
 // CHECK:       cir.call @_ZN6StringC2EPKc(%3, %5) : (!cir.ptr<!rec_String>, !cir.ptr<!s8i>) -> ()
 // CHECK:       cir.scope {
 // CHECK:         %6 = cir.alloca !rec_StringView, !cir.ptr<!rec_StringView>, ["ref.tmp0"] {alignment = 8 : i64}
@@ -124,8 +124,8 @@ struct ContainsNonTrivial {
 // 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:    %[[#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]]
@@ -135,8 +135,8 @@ struct ContainsNonTrivial {
 // 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:    %[[#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]]
@@ -168,8 +168,8 @@ struct Trivial {
 // 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
-// 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:    %[[#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:    cir.store{{.*}} %[[#THIS_LOAD]], %[[#RETVAL]]
 // CHECK-NEXT:    %[[#RETVAL_LOAD:]] = cir.load{{.*}} %[[#RETVAL]]
@@ -206,10 +206,10 @@ struct ContainsTrivialArray {
 // CHECK-SAME:    special_member<#cir.cxx_assign<!rec_ContainsTrivialArray, copy>>
 // 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:    %[[#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_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:    %[[#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
 // CHECK-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_ARR_CAST]] to %[[#THIS_ARR_CAST]]
 ContainsTrivialArray &
diff --git a/clang/test/CIR/CodeGen/atomic-thread-fence.c b/clang/test/CIR/CodeGen/atomic-thread-fence.c
index fe9025a7ce8f..22d9f65c45d3 100644
--- a/clang/test/CIR/CodeGen/atomic-thread-fence.c
+++ b/clang/test/CIR/CodeGen/atomic-thread-fence.c
@@ -86,11 +86,11 @@ void loadWithThreadFence(DataPtr d) {
 // 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:    %[[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:    %[[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:    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:    %[[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:    cir.return
 
@@ -115,11 +115,11 @@ void loadWithSignalFence(DataPtr d) {
 // 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:    %[[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:    %[[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:    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:    %[[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:    cir.return
 
diff --git a/clang/test/CIR/CodeGen/atomic-xchg-field.c b/clang/test/CIR/CodeGen/atomic-xchg-field.c
index 83a933095aec..aca99ec0c3df 100644
--- a/clang/test/CIR/CodeGen/atomic-xchg-field.c
+++ b/clang/test/CIR/CodeGen/atomic-xchg-field.c
@@ -27,7 +27,7 @@ void field_access(wPtr item) {
 // CHECK-NEXT: %[[WADDR:.*]] = cir.alloca !cir.ptr<![[W]]>, {{.*}} {alignment = 8 : i64}
 // 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: %[[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)
 
 // LLVM-LABEL: @field_access
@@ -78,7 +78,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:    %[[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:    cir.store{{.*}} %[[ATOMIC_LOAD]], %[[RES]] : !u64i, !cir.ptr<!u64i>
 
diff --git a/clang/test/CIR/CodeGen/atomic.cpp b/clang/test/CIR/CodeGen/atomic.cpp
index 380d47e8adf9..3575bbf9e713 100644
--- a/clang/test/CIR/CodeGen/atomic.cpp
+++ b/clang/test/CIR/CodeGen/atomic.cpp
@@ -597,9 +597,9 @@ 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: %[[CMP_U:.*]] = cir.cast(integral, %[[CMP]] : !s32i), !u32i
+// CHECK: %[[CMP_U:.*]] = cir.cast integral %[[CMP]] : !s32i -> !u32i
 // CHECK: %[[UPD:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[UPD_U:.*]] = cir.cast(integral, %[[UPD]] : !s32i), !u32i
+// 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)
 // CHECK: cir.store{{.*}} %[[RES]], {{.*}} : !cir.bool, !cir.ptr<!cir.bool>
@@ -637,12 +637,12 @@ 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: %[[CMP_U:.*]] = cir.cast(integral, %[[CMP]] : !s32i), !u32i
+// CHECK: %[[CMP_U:.*]] = cir.cast integral %[[CMP]] : !s32i -> !u32i
 // CHECK: %[[UPD:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
-// CHECK: %[[UPD_U:.*]] = cir.cast(integral, %[[UPD]] : !s32i), !u32i
+// 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)
-// CHECK: %[[R:.*]] = cir.cast(integral, %[[OLD]] : !u32i), !s32i
+// CHECK: %[[R:.*]] = cir.cast integral %[[OLD]] : !u32i -> !s32i
 // CHECK: cir.store{{.*}} %[[R]], {{.*}} : !s32i, !cir.ptr<!s32i>
 
 // LLVM-LABEL: @_Z12cmp_val_uint
@@ -678,7 +678,7 @@ void cmp_val_ulong(unsigned long* p, long x, long u) {
 // LLVM-LABEL: @test_op_and_fetch
 extern "C" void test_op_and_fetch(void)
 {
-  // CHECK: [[VAL0:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s8i
+  // CHECK: [[VAL0:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s8i
   // CHECK: [[RES0:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!s8i>, [[VAL0]] : !s8i, seq_cst) fetch_first : !s8i
   // CHECK: [[RET0:%.*]] = cir.binop(add, [[RES0]], [[VAL0]]) : !s8i
   // LLVM:  [[VAL0:%.*]] = load i8, ptr @uc, align 1
@@ -695,7 +695,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i8 [[RET1]], ptr @uc, align 1
   uc = __sync_add_and_fetch(&uc, uc);
 
-  // CHECK: [[VAL2:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s16i
+  // CHECK: [[VAL2:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s16i
   // CHECK: [[RES2:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!s16i>, [[VAL2]] : !s16i, seq_cst) fetch_first : !s16i
   // CHECK: [[RET2:%.*]] = cir.binop(add, [[RES2]], [[VAL2]]) : !s16i
   // LLVM:  [[VAL2:%.*]] = load i8, ptr @uc, align 1
@@ -705,7 +705,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET2]], ptr @ss, align 2
   ss = __sync_add_and_fetch(&ss, uc);
 
-  // CHECK: [[VAL3:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u16i
+  // CHECK: [[VAL3:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u16i
   // CHECK: [[RES3:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!u16i>, [[VAL3]] : !u16i, seq_cst) fetch_first : !u16i
   // CHECK: [[RET3:%.*]] = cir.binop(add, [[RES3]], [[VAL3]]) : !u16i
   // LLVM:  [[VAL3:%.*]] = load i8, ptr @uc, align 1
@@ -715,7 +715,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET3]], ptr @us
   us = __sync_add_and_fetch(&us, uc);
 
-  // CHECK: [[VAL4:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s32i
+  // CHECK: [[VAL4:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s32i
   // CHECK: [[RES4:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!s32i>, [[VAL4]] : !s32i, seq_cst) fetch_first : !s32i
   // CHECK: [[RET4:%.*]] = cir.binop(add, [[RES4]], [[VAL4]]) : !s32i
   // LLVM:  [[VAL4:%.*]] = load i8, ptr @uc, align 1
@@ -725,7 +725,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET4]], ptr @si, align 4
   si = __sync_add_and_fetch(&si, uc);
 
-  // CHECK: [[VAL5:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u32i
+  // CHECK: [[VAL5:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u32i
   // CHECK: [[RES5:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!u32i>, [[VAL5]] : !u32i, seq_cst) fetch_first : !u32i
   // CHECK: [[RET5:%.*]] = cir.binop(add, [[RES5]], [[VAL5]]) : !u32i
   // LLVM:  [[VAL5:%.*]] = load i8, ptr @uc, align 1
@@ -735,7 +735,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET5]], ptr @ui, align 4
   ui = __sync_add_and_fetch(&ui, uc);
 
-  // CHECK: [[VAL6:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s64i
+  // CHECK: [[VAL6:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s64i
   // CHECK: [[RES6:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!s64i>, [[VAL6]] : !s64i, seq_cst) fetch_first : !s64i
   // CHECK: [[RET6:%.*]] = cir.binop(add, [[RES6]], [[VAL6]]) : !s64i
   // LLVM:  [[VAL6:%.*]] = load i8, ptr @uc, align 1
@@ -745,7 +745,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET6]], ptr @sll, align 8
   sll = __sync_add_and_fetch(&sll, uc);
 
-  // CHECK: [[VAL7:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u64i
+  // CHECK: [[VAL7:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u64i
   // CHECK: [[RES7:%.*]] = cir.atomic.fetch(add, {{%.*}} : !cir.ptr<!u64i>, [[VAL7]] : !u64i, seq_cst) fetch_first : !u64i
   // CHECK: [[RET7:%.*]] = cir.binop(add, [[RES7]], [[VAL7]]) : !u64i
   // LLVM:  [[VAL7:%.*]] = load i8, ptr @uc, align 1
@@ -755,7 +755,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET7]], ptr @ull, align 8
   ull = __sync_add_and_fetch(&ull, uc);
 
-  // CHECK: [[VAL0:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s8i
+  // CHECK: [[VAL0:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s8i
   // CHECK: [[RES0:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!s8i>, [[VAL0]] : !s8i, seq_cst) fetch_first : !s8i
   // CHECK: [[RET0:%.*]] = cir.binop(sub, [[RES0]], [[VAL0]]) : !s8i
   // LLVM:  [[VAL0:%.*]] = load i8, ptr @uc, align 1
@@ -772,7 +772,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i8 [[RET1]], ptr @uc, align 1
   uc = __sync_sub_and_fetch(&uc, uc);
 
-  // CHECK: [[VAL2:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s16i
+  // CHECK: [[VAL2:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s16i
   // CHECK: [[RES2:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!s16i>, [[VAL2]] : !s16i, seq_cst) fetch_first : !s16i
   // CHECK: [[RET2:%.*]] = cir.binop(sub, [[RES2]], [[VAL2]]) : !s16i
   // LLVM:  [[VAL2:%.*]] = load i8, ptr @uc, align 1
@@ -782,7 +782,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET2]], ptr @ss, align 2
   ss = __sync_sub_and_fetch(&ss, uc);
 
-  // CHECK: [[VAL3:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u16i
+  // CHECK: [[VAL3:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u16i
   // CHECK: [[RES3:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!u16i>, [[VAL3]] : !u16i, seq_cst) fetch_first : !u16i
   // CHECK: [[RET3:%.*]] = cir.binop(sub, [[RES3]], [[VAL3]]) : !u16i
   // LLVM:  [[VAL3:%.*]] = load i8, ptr @uc, align 1
@@ -792,7 +792,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET3]], ptr @us
   us = __sync_sub_and_fetch(&us, uc);
 
-  // CHECK: [[VAL4:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s32i
+  // CHECK: [[VAL4:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s32i
   // CHECK: [[RES4:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!s32i>, [[VAL4]] : !s32i, seq_cst) fetch_first : !s32i
   // CHECK: [[RET4:%.*]] = cir.binop(sub, [[RES4]], [[VAL4]]) : !s32i
   // LLVM:  [[VAL4:%.*]] = load i8, ptr @uc, align 1
@@ -802,7 +802,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET4]], ptr @si, align 4
   si = __sync_sub_and_fetch(&si, uc);
 
-  // CHECK: [[VAL5:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u32i
+  // CHECK: [[VAL5:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u32i
   // CHECK: [[RES5:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!u32i>, [[VAL5]] : !u32i, seq_cst) fetch_first : !u32i
   // CHECK: [[RET5:%.*]] = cir.binop(sub, [[RES5]], [[VAL5]]) : !u32i
   // LLVM:  [[VAL5:%.*]] = load i8, ptr @uc, align 1
@@ -812,7 +812,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET5]], ptr @ui, align 4
   ui = __sync_sub_and_fetch(&ui, uc);
 
-  // CHECK: [[VAL6:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s64i
+  // CHECK: [[VAL6:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s64i
   // CHECK: [[RES6:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!s64i>, [[VAL6]] : !s64i, seq_cst) fetch_first : !s64i
   // CHECK: [[RET6:%.*]] = cir.binop(sub, [[RES6]], [[VAL6]]) : !s64i
   // LLVM:  [[VAL6:%.*]] = load i8, ptr @uc, align 1
@@ -822,7 +822,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET6]], ptr @sll, align 8
   sll = __sync_sub_and_fetch(&sll, uc);
 
-  // CHECK: [[VAL7:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u64i
+  // CHECK: [[VAL7:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u64i
   // CHECK: [[RES7:%.*]] = cir.atomic.fetch(sub, {{%.*}} : !cir.ptr<!u64i>, [[VAL7]] : !u64i, seq_cst) fetch_first : !u64i
   // CHECK: [[RET7:%.*]] = cir.binop(sub, [[RES7]], [[VAL7]]) : !u64i
   // LLVM:  [[VAL7:%.*]] = load i8, ptr @uc, align 1
@@ -832,7 +832,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET7]], ptr @ull, align 8
   ull = __sync_sub_and_fetch(&ull, uc);
 
-  // CHECK: [[VAL0:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s8i
+  // CHECK: [[VAL0:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s8i
   // CHECK: [[RES0:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!s8i>, [[VAL0]] : !s8i, seq_cst) fetch_first : !s8i
   // CHECK: [[RET0:%.*]] = cir.binop(and, [[RES0]], [[VAL0]]) : !s8i
   // LLVM:  [[VAL0:%.*]] = load i8, ptr @uc, align 1
@@ -849,7 +849,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i8 [[RET1]], ptr @uc, align 1
   uc = __sync_and_and_fetch(&uc, uc);
 
-  // CHECK: [[VAL2:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s16i
+  // CHECK: [[VAL2:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s16i
   // CHECK: [[RES2:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!s16i>, [[VAL2]] : !s16i, seq_cst) fetch_first : !s16i
   // CHECK: [[RET2:%.*]] = cir.binop(and, [[RES2]], [[VAL2]]) : !s16i
   // LLVM:  [[VAL2:%.*]] = load i8, ptr @uc, align 1
@@ -859,7 +859,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET2]], ptr @ss, align 2
   ss = __sync_and_and_fetch(&ss, uc);
 
-  // CHECK: [[VAL3:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u16i
+  // CHECK: [[VAL3:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u16i
   // CHECK: [[RES3:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!u16i>, [[VAL3]] : !u16i, seq_cst) fetch_first : !u16i
   // CHECK: [[RET3:%.*]] = cir.binop(and, [[RES3]], [[VAL3]]) : !u16i
   // LLVM:  [[VAL3:%.*]] = load i8, ptr @uc, align 1
@@ -869,7 +869,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET3]], ptr @us
   us = __sync_and_and_fetch(&us, uc);
 
-  // CHECK: [[VAL4:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s32i
+  // CHECK: [[VAL4:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s32i
   // CHECK: [[RES4:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!s32i>, [[VAL4]] : !s32i, seq_cst) fetch_first : !s32i
   // CHECK: [[RET4:%.*]] = cir.binop(and, [[RES4]], [[VAL4]]) : !s32i
   // LLVM:  [[VAL4:%.*]] = load i8, ptr @uc, align 1
@@ -879,7 +879,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET4]], ptr @si, align 4
   si = __sync_and_and_fetch(&si, uc);
 
-  // CHECK: [[VAL5:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u32i
+  // CHECK: [[VAL5:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u32i
   // CHECK: [[RES5:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!u32i>, [[VAL5]] : !u32i, seq_cst) fetch_first : !u32i
   // CHECK: [[RET5:%.*]] = cir.binop(and, [[RES5]], [[VAL5]]) : !u32i
   // LLVM:  [[VAL5:%.*]] = load i8, ptr @uc, align 1
@@ -889,7 +889,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET5]], ptr @ui, align 4
   ui = __sync_and_and_fetch(&ui, uc);
 
-  // CHECK: [[VAL6:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s64i
+  // CHECK: [[VAL6:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s64i
   // CHECK: [[RES6:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!s64i>, [[VAL6]] : !s64i, seq_cst) fetch_first : !s64i
   // CHECK: [[RET6:%.*]] = cir.binop(and, [[RES6]], [[VAL6]]) : !s64i
   // LLVM:  [[VAL6:%.*]] = load i8, ptr @uc, align 1
@@ -899,7 +899,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET6]], ptr @sll, align 8
   sll = __sync_and_and_fetch(&sll, uc);
 
-  // CHECK: [[VAL7:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u64i
+  // CHECK: [[VAL7:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u64i
   // CHECK: [[RES7:%.*]] = cir.atomic.fetch(and, {{%.*}} : !cir.ptr<!u64i>, [[VAL7]] : !u64i, seq_cst) fetch_first : !u64i
   // CHECK: [[RET7:%.*]] = cir.binop(and, [[RES7]], [[VAL7]]) : !u64i
   // LLVM:  [[VAL7:%.*]] = load i8, ptr @uc, align 1
@@ -909,7 +909,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET7]], ptr @ull, align 8
   ull = __sync_and_and_fetch(&ull, uc);
 
-  // CHECK: [[VAL0:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s8i
+  // CHECK: [[VAL0:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s8i
   // CHECK: [[RES0:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!s8i>, [[VAL0]] : !s8i, seq_cst) fetch_first : !s8i
   // CHECK: [[RET0:%.*]] = cir.binop(or, [[RES0]], [[VAL0]]) : !s8i
   // LLVM:  [[VAL0:%.*]] = load i8, ptr @uc, align 1
@@ -926,7 +926,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i8 [[RET1]], ptr @uc, align 1
   uc = __sync_or_and_fetch(&uc, uc);
 
-  // CHECK: [[VAL2:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s16i
+  // CHECK: [[VAL2:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s16i
   // CHECK: [[RES2:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!s16i>, [[VAL2]] : !s16i, seq_cst) fetch_first : !s16i
   // CHECK: [[RET2:%.*]] = cir.binop(or, [[RES2]], [[VAL2]]) : !s16i
   // LLVM:  [[VAL2:%.*]] = load i8, ptr @uc, align 1
@@ -936,7 +936,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET2]], ptr @ss, align 2
   ss = __sync_or_and_fetch(&ss, uc);
 
-  // CHECK: [[VAL3:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u16i
+  // CHECK: [[VAL3:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u16i
   // CHECK: [[RES3:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!u16i>, [[VAL3]] : !u16i, seq_cst) fetch_first : !u16i
   // CHECK: [[RET3:%.*]] = cir.binop(or, [[RES3]], [[VAL3]]) : !u16i
   // LLVM:  [[VAL3:%.*]] = load i8, ptr @uc, align 1
@@ -946,7 +946,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET3]], ptr @us
   us = __sync_or_and_fetch(&us, uc);
 
-  // CHECK: [[VAL4:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s32i
+  // CHECK: [[VAL4:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s32i
   // CHECK: [[RES4:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!s32i>, [[VAL4]] : !s32i, seq_cst) fetch_first : !s32i
   // CHECK: [[RET4:%.*]] = cir.binop(or, [[RES4]], [[VAL4]]) : !s32i
   // LLVM:  [[VAL4:%.*]] = load i8, ptr @uc, align 1
@@ -956,7 +956,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET4]], ptr @si, align 4
   si = __sync_or_and_fetch(&si, uc);
 
-  // CHECK: [[VAL5:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u32i
+  // CHECK: [[VAL5:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u32i
   // CHECK: [[RES5:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!u32i>, [[VAL5]] : !u32i, seq_cst) fetch_first : !u32i
   // CHECK: [[RET5:%.*]] = cir.binop(or, [[RES5]], [[VAL5]]) : !u32i
   // LLVM:  [[VAL5:%.*]] = load i8, ptr @uc, align 1
@@ -966,7 +966,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET5]], ptr @ui, align 4
   ui = __sync_or_and_fetch(&ui, uc);
 
-  // CHECK: [[VAL6:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s64i
+  // CHECK: [[VAL6:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s64i
   // CHECK: [[RES6:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!s64i>, [[VAL6]] : !s64i, seq_cst) fetch_first : !s64i
   // CHECK: [[RET6:%.*]] = cir.binop(or, [[RES6]], [[VAL6]]) : !s64i
   // LLVM:  [[VAL6:%.*]] = load i8, ptr @uc, align 1
@@ -976,7 +976,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET6]], ptr @sll, align 8
   sll = __sync_or_and_fetch(&sll, uc);
 
-  // CHECK: [[VAL7:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u64i
+  // CHECK: [[VAL7:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u64i
   // CHECK: [[RES7:%.*]] = cir.atomic.fetch(or, {{%.*}} : !cir.ptr<!u64i>, [[VAL7]] : !u64i, seq_cst) fetch_first : !u64i
   // CHECK: [[RET7:%.*]] = cir.binop(or, [[RES7]], [[VAL7]]) : !u64i
   // LLVM:  [[VAL7:%.*]] = load i8, ptr @uc, align 1
@@ -986,7 +986,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET7]], ptr @ull, align 8
   ull = __sync_or_and_fetch(&ull, uc);
 
-  // CHECK: [[VAL0:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s8i
+  // CHECK: [[VAL0:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s8i
   // CHECK: [[RES0:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!s8i>, [[VAL0]] : !s8i, seq_cst) fetch_first : !s8i
   // CHECK: [[RET0:%.*]] = cir.binop(xor, [[RES0]], [[VAL0]]) : !s8i
   // LLVM:  [[VAL0:%.*]] = load i8, ptr @uc, align 1
@@ -1003,7 +1003,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i8 [[RET1]], ptr @uc, align 1
   uc = __sync_xor_and_fetch(&uc, uc);
 
-  // CHECK: [[VAL2:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s16i
+  // CHECK: [[VAL2:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s16i
   // CHECK: [[RES2:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!s16i>, [[VAL2]] : !s16i, seq_cst) fetch_first : !s16i
   // CHECK: [[RET2:%.*]] = cir.binop(xor, [[RES2]], [[VAL2]]) : !s16i
   // LLVM:  [[VAL2:%.*]] = load i8, ptr @uc, align 1
@@ -1013,7 +1013,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET2]], ptr @ss, align 2
   ss = __sync_xor_and_fetch(&ss, uc);
 
-  // CHECK: [[VAL3:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u16i
+  // CHECK: [[VAL3:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u16i
   // CHECK: [[RES3:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!u16i>, [[VAL3]] : !u16i, seq_cst) fetch_first : !u16i
   // CHECK: [[RET3:%.*]] = cir.binop(xor, [[RES3]], [[VAL3]]) : !u16i
   // LLVM:  [[VAL3:%.*]] = load i8, ptr @uc, align 1
@@ -1023,7 +1023,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET3]], ptr @us
   us = __sync_xor_and_fetch(&us, uc);
 
-  // CHECK: [[VAL4:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s32i
+  // CHECK: [[VAL4:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s32i
   // CHECK: [[RES4:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!s32i>, [[VAL4]] : !s32i, seq_cst) fetch_first : !s32i
   // CHECK: [[RET4:%.*]] = cir.binop(xor, [[RES4]], [[VAL4]]) : !s32i
   // LLVM:  [[VAL4:%.*]] = load i8, ptr @uc, align 1
@@ -1033,7 +1033,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET4]], ptr @si, align 4
   si = __sync_xor_and_fetch(&si, uc);
 
-  // CHECK: [[VAL5:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u32i
+  // CHECK: [[VAL5:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u32i
   // CHECK: [[RES5:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!u32i>, [[VAL5]] : !u32i, seq_cst) fetch_first : !u32i
   // CHECK: [[RET5:%.*]] = cir.binop(xor, [[RES5]], [[VAL5]]) : !u32i
   // LLVM:  [[VAL5:%.*]] = load i8, ptr @uc, align 1
@@ -1043,7 +1043,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET5]], ptr @ui, align 4
   ui = __sync_xor_and_fetch(&ui, uc);
 
-  // CHECK: [[VAL6:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s64i
+  // CHECK: [[VAL6:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s64i
   // CHECK: [[RES6:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!s64i>, [[VAL6]] : !s64i, seq_cst) fetch_first : !s64i
   // CHECK: [[RET6:%.*]] = cir.binop(xor, [[RES6]], [[VAL6]]) : !s64i
   // LLVM:  [[VAL6:%.*]] = load i8, ptr @uc, align 1
@@ -1053,7 +1053,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET6]], ptr @sll, align 8
   sll = __sync_xor_and_fetch(&sll, uc);
 
-  // CHECK: [[VAL7:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u64i
+  // CHECK: [[VAL7:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u64i
   // CHECK: [[RES7:%.*]] = cir.atomic.fetch(xor, {{%.*}} : !cir.ptr<!u64i>, [[VAL7]] : !u64i, seq_cst) fetch_first : !u64i
   // CHECK: [[RET7:%.*]] = cir.binop(xor, [[RES7]], [[VAL7]]) : !u64i
   // LLVM:  [[VAL7:%.*]] = load i8, ptr @uc, align 1
@@ -1063,7 +1063,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET7]], ptr @ull, align 8
   ull = __sync_xor_and_fetch(&ull, uc);
 
-  // CHECK: [[VAL0:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s8i
+  // CHECK: [[VAL0:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s8i
   // CHECK: [[RES0:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!s8i>, [[VAL0]] : !s8i, seq_cst) fetch_first : !s8i
   // CHECK: [[INTERM0:%.*]] = cir.binop(and, [[RES0]], [[VAL0]]) : !s8i
   // CHECK: [[RET0:%.*]] =  cir.unary(not, [[INTERM0]]) : !s8i, !s8i
@@ -1084,7 +1084,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i8 [[RET1]], ptr @uc, align 1
   uc = __sync_nand_and_fetch(&uc, uc);
 
-  // CHECK: [[VAL2:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s16i
+  // CHECK: [[VAL2:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s16i
   // CHECK: [[RES2:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!s16i>, [[VAL2]] : !s16i, seq_cst) fetch_first : !s16i
   // CHECK: [[INTERM2:%.*]] = cir.binop(and, [[RES2]], [[VAL2]]) : !s16i
   // CHECK: [[RET2:%.*]] =  cir.unary(not, [[INTERM2]]) : !s16i, !s16i
@@ -1096,7 +1096,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET2]], ptr @ss, align 2
   ss = __sync_nand_and_fetch(&ss, uc);
 
-  // CHECK: [[VAL3:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u16i
+  // CHECK: [[VAL3:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u16i
   // CHECK: [[RES3:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!u16i>, [[VAL3]] : !u16i, seq_cst) fetch_first : !u16i
   // CHECK: [[INTERM3:%.*]] = cir.binop(and, [[RES3]], [[VAL3]]) : !u16i
   // CHECK: [[RET3:%.*]] =  cir.unary(not, [[INTERM3]]) : !u16i, !u16i
@@ -1108,7 +1108,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i16 [[RET3]], ptr @us, align 2
   us = __sync_nand_and_fetch(&us, uc);
 
-  // CHECK: [[VAL4:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s32i
+  // CHECK: [[VAL4:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s32i
   // CHECK: [[RES4:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!s32i>, [[VAL4]] : !s32i, seq_cst) fetch_first : !s32i
   // CHECK: [[INTERM4:%.*]] = cir.binop(and, [[RES4]], [[VAL4]]) : !s32i
   // CHECK: [[RET4:%.*]] =  cir.unary(not, [[INTERM4]]) : !s32i, !s32i
@@ -1120,7 +1120,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET4]], ptr @si, align 4
   si = __sync_nand_and_fetch(&si, uc);
 
-  // CHECK: [[VAL5:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u32i
+  // CHECK: [[VAL5:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u32i
   // CHECK: [[RES5:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!u32i>, [[VAL5]] : !u32i, seq_cst) fetch_first : !u32i
   // CHECK: [[INTERM5:%.*]] = cir.binop(and, [[RES5]], [[VAL5]]) : !u32i
   // CHECK: [[RET5:%.*]] =  cir.unary(not, [[INTERM5]]) : !u32i, !u32i
@@ -1132,7 +1132,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i32 [[RET5]], ptr @ui, align 4
   ui = __sync_nand_and_fetch(&ui, uc);
 
-  // CHECK: [[VAL6:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !s64i
+  // CHECK: [[VAL6:%.*]] = cir.cast integral {{%.*}} : !u8i -> !s64i
   // CHECK: [[RES6:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!s64i>, [[VAL6]] : !s64i, seq_cst) fetch_first : !s64i
   // CHECK: [[INTERM6:%.*]] = cir.binop(and, [[RES6]], [[VAL6]]) : !s64i
   // CHECK: [[RET6:%.*]] =  cir.unary(not, [[INTERM6]]) : !s64i, !s64i
@@ -1144,7 +1144,7 @@ extern "C" void test_op_and_fetch(void)
   // LLVM:  store i64 [[RET6]], ptr @sll, align 8
   sll = __sync_nand_and_fetch(&sll, uc);
 
-  // CHECK: [[VAL7:%.*]] = cir.cast(integral, {{%.*}} : !u8i), !u64i
+  // CHECK: [[VAL7:%.*]] = cir.cast integral {{%.*}} : !u8i -> !u64i
   // CHECK: [[RES7:%.*]] = cir.atomic.fetch(nand, {{%.*}} : !cir.ptr<!u64i>, [[VAL7]] : !u64i, seq_cst) fetch_first : !u64i
   // CHECK: [[INTERM7:%.*]] = cir.binop(and, [[RES7]], [[VAL7]]) : !u64i
   // CHECK: [[RET7:%.*]] =  cir.unary(not, [[INTERM7]]) : !u64i, !u64i
diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp
index 6e25371c5140..89ed36ea62e6 100644
--- a/clang/test/CIR/CodeGen/basic.cpp
+++ b/clang/test/CIR/CodeGen/basic.cpp
@@ -65,7 +65,7 @@ void b1(int a) { bool b = a; }
 
 // CHECK: cir.func dso_local @_Z2b1i(%arg0: !s32i loc({{.*}}))
 // CHECK: %2 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
-// CHECK: %3 = cir.cast(int_to_bool, %2 : !s32i), !cir.bool
+// CHECK: %3 = cir.cast int_to_bool %2 : !s32i -> !cir.bool
 // CHECK: cir.store{{.*}} %3, %1 : !cir.bool, !cir.ptr<!cir.bool>
 
 void if0(int a) {
@@ -80,7 +80,7 @@ void if0(int a) {
 // CHECK: cir.func dso_local @_Z3if0i(%arg0: !s32i loc({{.*}}))
 // CHECK: cir.scope {
 // CHECK:   %3 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
-// CHECK:   %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
+// 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
 // CHECK-NEXT:     cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
@@ -108,7 +108,7 @@ void if1(int a, bool b, bool c) {
 // CHECK: cir.func dso_local @_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:   %6 = cir.cast(int_to_bool, %5 : !s32i), !cir.bool
+// 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>
@@ -173,7 +173,7 @@ size_type max_size() {
 // CHECK:   %0 = cir.alloca !u64i, !cir.ptr<!u64i>, ["__retval"] {alignment = 8 : i64}
 // CHECK:   %1 = cir.const #cir.int<0> : !s32i
 // CHECK:   %2 = cir.unary(not, %1) : !s32i, !s32i
-// CHECK:   %3 = cir.cast(integral, %2 : !s32i), !u64i
+// CHECK:   %3 = cir.cast integral %2 : !s32i -> !u64i
 // CHECK:   %4 = cir.const #cir.int<8> : !u64i
 // CHECK:   %5 = cir.binop(div, %3, %4) : !u64i
 
diff --git a/clang/test/CIR/CodeGen/bf16-ops.c b/clang/test/CIR/CodeGen/bf16-ops.c
index 0504f96e721d..7aa53752d9dd 100644
--- a/clang/test/CIR/CodeGen/bf16-ops.c
+++ b/clang/test/CIR/CodeGen/bf16-ops.c
@@ -16,29 +16,29 @@ short s0;
 
 void foo(void) {
   test = (h0);
-  // NONATIVE: %{{.+}} = cir.cast(float_to_int, %{{.+}} : !cir.bf16), !u32i
-  // NATIVE: %{{.+}} = cir.cast(float_to_int, %{{.+}} : !cir.bf16), !u32i
+  // NONATIVE: %{{.+}} = cir.cast float_to_int %{{.+}} : !cir.bf16 -> !u32i
+  // NATIVE: %{{.+}} = cir.cast float_to_int %{{.+}} : !cir.bf16 -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fptoui bfloat %{{.+}} to i32
   // NATIVE-LLVM: %{{.+}} = fptoui bfloat %{{.+}} to i32
 
   h0 = (test);
-  // NONATIVE: %{{.+}} = cir.cast(int_to_float, %{{.+}} : !u32i), !cir.bf16
-  // NATIVE: %{{.+}} = cir.cast(int_to_float, %{{.+}} : !u32i), !cir.bf16
+  // NONATIVE: %{{.+}} = cir.cast int_to_float %{{.+}} : !u32i -> !cir.bf16
+  // NATIVE: %{{.+}} = cir.cast int_to_float %{{.+}} : !u32i -> !cir.bf16
 
   // NONATIVE-LLVM: %{{.+}} = uitofp i32 %{{.+}} to bfloat
   // NATIVE-LLVM: %{{.+}} = uitofp i32 %{{.+}} to bfloat
 
   test = (!h1);
-  //      NONATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.bf16), !cir.bool
+  //      NONATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.bf16 -> !cir.bool
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(not, %[[#A]]) : !cir.bool, !cir.bool
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.bf16), !cir.bool
+  //      NATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.bf16 -> !cir.bool
   // NATIVE-NEXT: %[[#B:]] = cir.unary(not, %[[#A]]) : !cir.bool, !cir.bool
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#A:]] = fcmp une bfloat %{{.+}}, 0xR0000
   // NONATIVE-LLVM-NEXT: %[[#C:]] = xor i1 %[[#A]], true
@@ -49,12 +49,12 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = zext i1 %[[#C]] to i32
 
   h1 = -h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.float), !cir.bf16
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.float -> !cir.bf16
   //      NATIVE: %{{.+}} = cir.unary(minus, %{{.+}}) : !cir.bf16, !cir.bf16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -64,12 +64,12 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fneg bfloat %{{.+}}
 
   h1 = +h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(plus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.float), !cir.bf16
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.float -> !cir.bf16
   //      NATIVE: %{{.+}} = cir.unary(plus, %{{.+}}) : !cir.bf16, !cir.bf16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -123,10 +123,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd bfloat %{{.+}}, 0xRBF80
 
   h1 = h0 * h2;
-  //      NONATIVE: %[[#LHS:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#RHS:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#LHS:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#RHS:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#A:]] = cir.binop(mul, %[[#LHS]], %[[#RHS]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#A]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#A]] : !cir.float -> !cir.bf16
 
   // NATIVE: %{{.+}} = cir.binop(mul, %{{.+}}, %{{.+}}) : !cir.bf16
 
@@ -138,17 +138,17 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul bfloat %{{.+}}, %{{.+}}
 
   h1 = h0 * (__bf16) -2.0f;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.unary(minus, %[[#B]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.bf16), !cir.float
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(mul, %[[#A]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.bf16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NATIVE-NEXT: %{{.+}} = cir.binop(mul, %{{.+}}, %[[#C]]) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -158,13 +158,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul bfloat %{{.+}}, 0xRC000
 
   h1 = h0 * f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   //      NONATIVE-LLVM: %[[#RES:]] = fmul float %[[#LHS]], %{{.+}}
@@ -175,13 +175,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = f0 * h2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fmul float %{{.+}}, %[[#RHS]]
@@ -192,13 +192,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = h0 * i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(mul, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %{{.+}} = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
@@ -211,10 +211,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fmul bfloat %{{.+}}, %[[#A]]
 
   h1 = (h0 / h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(div, %[[#A]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
 
   // NATIVE: %{{.+}} = cir.binop(div, %{{.+}}, %{{.+}}) : !cir.bf16
 
@@ -226,17 +226,17 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fdiv bfloat %{{.+}}, %{{.+}}
 
   h1 = (h0 / (__bf16) -2.0f);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.unary(minus, %[[#B]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.bf16), !cir.float
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(div, %[[#A]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.bf16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NATIVE-NEXT: %{{.+}} = cir.binop(div, %{{.+}}, %[[#C]]) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -246,13 +246,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fdiv bfloat %{{.+}}, 0xRC000
 
   h1 = (h0 / f2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   //      NONATIVE-LLVM: %[[#RES:]] = fdiv float %[[#LHS]], %{{.+}}
@@ -263,13 +263,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = (f0 / h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fdiv float %{{.+}}, %[[#RHS]]
@@ -280,13 +280,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = (h0 / i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(div, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %{{.+}} = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
@@ -299,10 +299,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fdiv bfloat %{{.+}}, %[[#A]]
 
   h1 = (h2 + h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(add, %[[#A]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
 
   // NATIVE: %{{.+}} = cir.binop(add, %{{.+}}, %{{.+}}) : !cir.bf16
 
@@ -316,15 +316,15 @@ void foo(void) {
   h1 = ((__bf16)-2.0 + h0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#E:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.bf16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#E:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(add, %[[#D]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.bf16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.bf16
   //      NATIVE: %{{.+}} = cir.binop(add, %[[#C]], %{{.+}}) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -334,13 +334,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd bfloat 0xRC000, %{{.+}}
 
   h1 = (h2 + f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RHS:]] = load volatile float, ptr @f0, align 4
@@ -353,13 +353,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = (f2 + h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fadd float %{{.+}}, %[[#RHS]]
@@ -370,13 +370,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = (h0 + i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(add, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %{{.+}} = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
@@ -389,10 +389,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fadd bfloat %{{.+}}, %[[#A]]
 
   h1 = (h2 - h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(sub, %[[#A]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
 
   // NATIVE: %{{.+}} = cir.binop(sub, %{{.+}}, %{{.+}}) : !cir.bf16
 
@@ -406,15 +406,15 @@ void foo(void) {
   h1 = ((__bf16)-2.0f - h0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#E:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#E:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(sub, %[[#D]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.bf16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   //      NATIVE: %{{.+}} = cir.binop(sub, %[[#C]], %{{.+}}) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -424,13 +424,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub bfloat 0xRC000, %{{.+}}
 
   h1 = (h2 - f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RHS:]] = load volatile float, ptr @f0, align 4
@@ -443,13 +443,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = (f2 - h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fsub float %{{.+}}, %[[#RHS]]
@@ -460,13 +460,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to bfloat
 
   h1 = (h0 - i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(sub, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %{{.+}} = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.bf16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
@@ -480,10 +480,10 @@ void foo(void) {
 
   test = (h2 < h0);
   //      NONATIVE: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp olt bfloat %{{.+}}, %{{.+}}
 
@@ -491,27 +491,27 @@ void foo(void) {
 
   test = (h2 < (__bf16)42.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp olt bfloat %{{.+}}, 0xR4228
 
   // NATIVE-LLVM: %{{.+}} = fcmp olt bfloat %{{.+}}, 0xR4228
 
   test = (h2 < f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp olt float %[[#LHS]], %{{.+}}
@@ -520,13 +520,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp olt float %[[#LHS]], %{{.+}}
 
   test = (f2 < h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp olt float %{{.+}}, %[[#RHS]]
@@ -535,13 +535,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp olt float %{{.+}}, %[[#RHS]]
 
   test = (i0 < h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM: %{{.+}} = fcmp olt bfloat %[[#LHS]], %{{.+}}
@@ -550,13 +550,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp olt bfloat %[[#LHS]], %{{.+}}
 
   test = (h0 < i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp olt bfloat %{{.+}}, %[[#RHS]]
@@ -566,10 +566,10 @@ void foo(void) {
 
   test = (h0 > h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt bfloat %{{.+}}, %{{.+}}
 
@@ -577,27 +577,27 @@ void foo(void) {
 
   test = ((__bf16)42.0 > h2);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   //      NONATIVE: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   //      NATIVE: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt bfloat 0xR4228, %{{.+}}
 
   // NATIVE-LLVM: %{{.+}} = fcmp ogt bfloat 0xR4228, %{{.+}}
 
   test = (h0 > f2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt float %[[#LHS]], %{{.+}}
@@ -606,13 +606,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ogt float %[[#LHS]], %{{.+}}
 
   test = (f0 > h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt float %{{.+}}, %[[#RHS]]
@@ -621,13 +621,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ogt float %{{.+}}, %[[#RHS]]
 
   test = (i0 > h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt bfloat %[[#LHS]], %{{.+}}
@@ -636,13 +636,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ogt bfloat %[[#LHS]], %{{.+}}
 
   test = (h0 > i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ogt bfloat %{{.+}}, %[[#RHS]]
@@ -652,10 +652,10 @@ void foo(void) {
 
   test = (h2 <= h0);
   //      NONATIVE: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ole bfloat %{{.+}}, %{{.+}}
 
@@ -663,27 +663,27 @@ void foo(void) {
 
   test = (h2 <= (__bf16)42.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ole bfloat %{{.+}}, 0xR4228
 
   // NATIVE-LLVM: %{{.+}} = fcmp ole bfloat %{{.+}}, 0xR4228
 
   test = (h2 <= f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp ole float %[[#LHS]], %{{.+}}
@@ -692,13 +692,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ole float %[[#LHS]], %{{.+}}
 
   test = (f2 <= h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ole float %{{.+}}, %[[#RHS]]
@@ -707,13 +707,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp ole float %{{.+}}, %[[#RHS]]
 
   test = (i0 <= h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM: %{{.+}} = fcmp ole bfloat %[[#LHS]], %{{.+}}
@@ -722,13 +722,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ole bfloat %[[#LHS]], %{{.+}}
 
   test = (h0 <= i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ole bfloat %{{.+}}, %[[#RHS]]
@@ -738,12 +738,12 @@ void foo(void) {
 
   test = (h0 >= h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
   // NONATIVE-NEXT: %{{.+}} = cir.get_global @test : !cir.ptr<!u32i>
 
   //      NATIVE: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oge bfloat %{{.+}}, %{{.+}}
 
@@ -752,28 +752,28 @@ void foo(void) {
   test = (h0 >= (__bf16)-2.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.bf16
   // NONATIVE-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#D]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#D]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.bf16
   // NATIVE-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#D]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#D]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oge bfloat %{{.+}}, 0xRC000
 
   // NATIVE-LLVM: %{{.+}} = fcmp oge bfloat %{{.+}}, 0xRC000
 
   test = (h0 >= f2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp oge float %[[#LHS]], %{{.+}}
@@ -782,13 +782,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oge float %[[#LHS]], %{{.+}}
 
   test = (f0 >= h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp oge float %{{.+}}, %[[#RHS]]
@@ -797,13 +797,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oge float %{{.+}}, %[[#RHS]]
 
   test = (i0 >= h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM: %{{.+}} = fcmp oge bfloat %[[#LHS]], %{{.+}}
@@ -812,13 +812,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oge bfloat %[[#LHS]], %{{.+}}
 
   test = (h0 >= i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp oge bfloat %{{.+}}, %[[#RHS]]
@@ -828,10 +828,10 @@ void foo(void) {
 
   test = (h1 == h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq bfloat %{{.+}}, %{{.+}}
 
@@ -839,27 +839,27 @@ void foo(void) {
 
   test = (h1 == (__bf16)1.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NONATIVE-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq bfloat %{{.+}}, 0xR3F80
 
   // NATIVE-LLVM: %{{.+}} = fcmp oeq bfloat %{{.+}}, 0xR3F80
 
   test = (h1 == f1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq float %[[#A]], %{{.+}}
@@ -868,13 +868,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oeq float %[[#A]], %{{.+}}
 
   test = (f1 == h1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp oeq float %{{.+}}, %[[#RHS]]
@@ -883,13 +883,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp oeq float %{{.+}}, %[[#RHS]]
 
   test = (i0 == h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq bfloat %[[#LHS]], %{{.+}}
@@ -898,13 +898,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oeq bfloat %[[#LHS]], %{{.+}}
 
   test = (h0 == i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp oeq bfloat %{{.+}}, %[[#RHS]]
@@ -914,37 +914,37 @@ void foo(void) {
 
   test = (h1 != h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#A]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#A]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp une bfloat %{{.+}}, %{{.+}}
 
   // NATIVE-LLVM: %{{.+}} = fcmp une bfloat %{{.+}}, %{{.+}}
 
   test = (h1 != (__bf16)1.0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.double), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.double -> !cir.bf16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(ne, %{{.+}}, %[[#B]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#C]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#C]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp une bfloat %{{.+}}, 0xR3F80
 
   // NATIVE-LLVM: %{{.+}} = fcmp une bfloat %{{.+}}, 0xR3F80
 
   test = (h1 != f1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp une float %[[#LHS]], %{{.+}}
@@ -953,13 +953,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp une float %[[#LHS]], %{{.+}}
 
   test = (f1 != h1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp une float %{{.+}}, %[[#RHS]]
@@ -968,13 +968,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp une float %{{.+}}, %[[#RHS]]
 
   test = (i0 != h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NONATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM: %{{.+}} = fcmp une bfloat %[[#LHS]], %{{.+}}
@@ -983,13 +983,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp une bfloat %[[#LHS]], %{{.+}}
 
   test = (h0 != i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.bf16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to bfloat
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp une bfloat %{{.+}}, %[[#RHS]]
@@ -998,7 +998,7 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp une bfloat %{{.+}}, %[[#RHS]]
 
   h1 = (h1 ? h2 : h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.bf16), !cir.bool
+  //      NONATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.bf16 -> !cir.bool
   // NONATIVE-NEXT: %{{.+}} = cir.ternary(%[[#A]], true {
   //      NONATIVE:   cir.yield %{{.+}} : !cir.bf16
   // NONATIVE-NEXT: }, false {
@@ -1006,7 +1006,7 @@ void foo(void) {
   // NONATIVE-NEXT: }) : (!cir.bool) -> !cir.bf16
   //      NONATIVE: %{{.+}} = cir.get_global @h1 : !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.bf16), !cir.bool
+  //      NATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.bf16 -> !cir.bool
   // NATIVE-NEXT: %[[#B:]] = cir.ternary(%[[#A]], true {
   //      NATIVE:   cir.yield %{{.+}} : !cir.bf16
   // NATIVE-NEXT: }, false {
@@ -1057,13 +1057,13 @@ void foo(void) {
   h0 = (__bf16)-2.0f;
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // 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.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // 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>
 
@@ -1074,13 +1074,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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // 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>
 
@@ -1095,13 +1095,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: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.bf16
+  // 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: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.bf16
+  // 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>
 
@@ -1116,13 +1116,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: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
+  // 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: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
+  // 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>
 
@@ -1135,10 +1135,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: store volatile i32 %[[#B]], ptr @i0, align 4
 
   h0 += h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(add, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.binop(add, %{{.+}}, %{{.+}}) : !cir.bf16
@@ -1153,15 +1153,15 @@ void foo(void) {
 
   h0 += (__bf16)1.0f;
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.float
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.float), !cir.bf16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#D:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.float -> !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#D:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#E:]] = cir.binop(add, %[[#D]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %[[#F:]] = cir.cast(floating, %[[#E]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#F:]] = cir.cast floating %[[#E]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#F]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.float
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.float -> !cir.bf16
   //      NATIVE: %[[#C:]] = cir.binop(add, %{{.+}}, %[[#B]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1172,14 +1172,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd bfloat %{{.+}}, 0xR3F80
 
   h0 += f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -1191,15 +1191,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#B]] to bfloat
 
   i0 += h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(add, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.bf16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.bf16 -> !s32i
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
@@ -1212,14 +1212,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi bfloat %[[#A]] to i32
 
   h0 += i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(add, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#E]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#B]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1233,10 +1233,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd bfloat %{{.+}}, %[[#RHS]]
 
   h0 -= h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(sub, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.binop(sub, %{{.+}}, %{{.+}}) : !cir.bf16
@@ -1250,15 +1250,15 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub bfloat %{{.+}}, %{{.+}}
 
   h0 -= (__bf16)1.0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.double), !cir.bf16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.double -> !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(sub, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#E]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   //      NATIVE: %[[#C:]] = cir.binop(sub, %{{.+}}, %[[#B]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1269,14 +1269,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub bfloat %{{.+}}, 0xR3F80
 
   h0 -= f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -1288,15 +1288,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#B]] to bfloat
 
   i0 -= h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(sub, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.bf16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.bf16 -> !s32i
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
@@ -1309,14 +1309,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi bfloat %[[#A]] to i32
 
   h0 -= i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(sub, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#E]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#B]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1330,10 +1330,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub bfloat %{{.+}}, %[[#RHS]]
 
   h0 *= h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(mul, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.binop(mul, %{{.+}}, %{{.+}}) : !cir.bf16
@@ -1347,15 +1347,15 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul bfloat %{{.+}}, %{{.+}}
 
   h0 *= (__bf16)1.0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.double), !cir.bf16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.double -> !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(mul, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#E]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   //      NATIVE: %[[#C:]] = cir.binop(mul, %{{.+}}, %[[#B]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1366,14 +1366,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul bfloat %{{.+}}, 0xR3F80
 
   h0 *= f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -1385,15 +1385,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#B]] to bfloat
 
   i0 *= h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(mul, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.bf16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.bf16 -> !s32i
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
@@ -1406,14 +1406,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi bfloat %[[#A]] to i32
 
   h0 *= i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(mul, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#E]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#B]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1427,10 +1427,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul bfloat %{{.+}}, %[[#RHS]]
 
   h0 /= h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(div, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.binop(div, %{{.+}}, %{{.+}}) : !cir.bf16
@@ -1445,15 +1445,15 @@ void foo(void) {
 
   h0 /= (__bf16)1.0;
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#D:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#D:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#E:]] = cir.binop(div, %[[#D]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %[[#F:]] = cir.cast(floating, %[[#E]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#F:]] = cir.cast floating %[[#E]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#F]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.bf16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.bf16
   //      NATIVE: %[[#C:]] = cir.binop(div, %{{.+}}, %[[#B]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1464,14 +1464,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fdiv bfloat %{{.+}}, 0xR3F80
 
   h0 /= f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.bf16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext bfloat %{{.+}} to float
@@ -1483,15 +1483,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#B]] to bfloat
 
   i0 /= h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(div, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.bf16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.bf16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.bf16 -> !s32i
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext bfloat %{{.+}} to float
@@ -1504,14 +1504,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi bfloat %[[#A]] to i32
 
   h0 /= i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.bf16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.bf16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.bf16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.bf16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(div, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.bf16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.bf16
   // NONATIVE-NEXT: cir.store volatile{{.*}} %[[#E]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.bf16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.bf16
   //      NATIVE: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.bf16
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#B]], %{{.+}} : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1527,13 +1527,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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
+  // 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.bf16
+  // 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>
 
@@ -1548,15 +1548,15 @@ 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
-  // NATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.bf16
+  // 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>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %[[#E]] : !cir.bf16, !cir.ptr<!cir.bf16>
 
@@ -1573,13 +1573,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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.double
+  // 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.double
+  // 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>
 
@@ -1594,15 +1594,15 @@ 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
+  // 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.bf16), !cir.float
-  // NATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
+  // 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>
   // NATIVE-NEXT: cir.store volatile{{.*}} %[[#D]], %[[#E]] : !cir.double, !cir.ptr<!cir.double>
 
@@ -1619,13 +1619,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: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.bf16
+  // 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: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.bf16
+  // 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/binassign.cpp b/clang/test/CIR/CodeGen/binassign.cpp
index 934742d13404..17f4f7cb19a6 100644
--- a/clang/test/CIR/CodeGen/binassign.cpp
+++ b/clang/test/CIR/CodeGen/binassign.cpp
@@ -65,7 +65,7 @@ void exec() {
 // CHECK:   cir.scope {
 // CHECK:     %1 = cir.call @_Z5gettyv() : () -> !u32i
 // CHECK:     cir.store{{.*}} %1, %0 : !u32i, !cir.ptr<!u32i>
-// CHECK:     %2 = cir.cast(integral, %1 : !u32i), !s32i
+// CHECK:     %2 = cir.cast integral %1 : !u32i -> !s32i
 // CHECK:     %3 = cir.const #cir.int<0> : !s32i
 // CHECK:     %4 = cir.cmp(lt, %2, %3) : !s32i, !cir.bool
 // CHECK:     cir.if %4 {
diff --git a/clang/test/CIR/CodeGen/binop.c b/clang/test/CIR/CodeGen/binop.c
index 280fd29b067f..4427e4b60529 100644
--- a/clang/test/CIR/CodeGen/binop.c
+++ b/clang/test/CIR/CodeGen/binop.c
@@ -5,9 +5,9 @@ void conditionalResultIimplicitCast(int a, int b, float f) {
   // Should implicit cast back to int.
   int x = a && b;
   // CHECK: %[[#INT:]] = cir.ternary
-  // CHECK: %{{.+}} = cir.cast(bool_to_int, %[[#INT]] : !cir.bool), !s32i
+  // CHECK: %{{.+}} = cir.cast bool_to_int %[[#INT]] : !cir.bool -> !s32i
   float y = f && f;
   // CHECK: %[[#BOOL:]] = cir.ternary
-  // CHECK: %[[#INT:]] = cir.cast(bool_to_int, %[[#BOOL]] : !cir.bool), !s32i
-  // CHECK: %{{.+}} = cir.cast(int_to_float, %[[#INT]] : !s32i), !cir.float
+  // CHECK: %[[#INT:]] = cir.cast bool_to_int %[[#BOOL]] : !cir.bool -> !s32i
+  // CHECK: %{{.+}} = cir.cast int_to_float %[[#INT]] : !s32i -> !cir.float
 }
diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c
index 0c97c9c39ad0..141c5681a2c3 100644
--- a/clang/test/CIR/CodeGen/bitfields.c
+++ b/clang/test/CIR/CodeGen/bitfields.c
@@ -123,7 +123,7 @@ void createU() {
 // for this struct type we create an anon structure with different storage types in initialization
 // CHECK: cir.func {{.*@createD}}
 // CHECK:   %0 = cir.alloca !rec_D, !cir.ptr<!rec_D>, ["d"] {alignment = 4 : i64}
-// CHECK:   %1 = cir.cast(bitcast, %0 : !cir.ptr<!rec_D>), !cir.ptr<!rec_anon_struct>
+// CHECK:   %1 = cir.cast bitcast %0 : !cir.ptr<!rec_D> -> !cir.ptr<!rec_anon_struct>
 // CHECK:   %2 = cir.const #cir.const_record<{#cir.int<33> : !u8i, #cir.int<0> : !u8i, #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 2>, #cir.int<3> : !s32i}> : !rec_anon_struct
 // CHECK:   cir.store{{.*}} %2, %1 : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
 void createD() {
@@ -150,7 +150,7 @@ G g = { -123, 254UL};
 
 // CHECK: cir.func {{.*@get_y}}
 // 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:   %[[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
 int get_y() {
diff --git a/clang/test/CIR/CodeGen/bitint.c b/clang/test/CIR/CodeGen/bitint.c
index 8ff3dbcc4c76..5add80dd3749 100644
--- a/clang/test/CIR/CodeGen/bitint.c
+++ b/clang/test/CIR/CodeGen/bitint.c
@@ -9,14 +9,14 @@ void VLATest(_BitInt(3) A, _BitInt(42) B, _BitInt(17) C) {
 
 //      CHECK: cir.func dso_local @VLATest
 //      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:   %[[#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_PROMOTED:]] = cir.cast(integral, %[[#B]] : !cir.int<s, 42>), !u64i
+// 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_PROMOTED:]] = cir.cast(integral, %[[#C]] : !cir.int<s, 17>), !u64i
+// 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 029e11a111ad..1ebcae908c04 100644
--- a/clang/test/CIR/CodeGen/bitint.cpp
+++ b/clang/test/CIR/CodeGen/bitint.cpp
@@ -27,7 +27,7 @@ i10 test_init() {
 
 //      CHECK: cir.func dso_local @_Z9test_initv() -> !cir.int<s, 10>
 //      CHECK:   %[[#LITERAL:]] = cir.const #cir.int<42> : !s32i
-// CHECK-NEXT:   %{{.+}} = cir.cast(integral, %[[#LITERAL]] : !s32i), !cir.int<s, 10>
+// CHECK-NEXT:   %{{.+}} = cir.cast integral %[[#LITERAL]] : !s32i -> !cir.int<s, 10>
 //      CHECK: }
 
 void test_init_for_mem() {
@@ -36,7 +36,7 @@ void test_init_for_mem() {
 
 //      CHECK: cir.func dso_local @_Z17test_init_for_memv()
 //      CHECK:   %[[#LITERAL:]] = cir.const #cir.int<42> : !s32i
-// CHECK-NEXT:   %[[#INIT:]] = cir.cast(integral, %[[#LITERAL]] : !s32i), !cir.int<s, 10>
+// CHECK-NEXT:   %[[#INIT:]] = cir.cast integral %[[#LITERAL]] : !s32i -> !cir.int<s, 10>
 // CHECK-NEXT:   cir.store{{.*}} %[[#INIT]], %{{.+}} : !cir.int<s, 10>, !cir.ptr<!cir.int<s, 10>>
 //      CHECK: }
 
diff --git a/clang/test/CIR/CodeGen/bool.c b/clang/test/CIR/CodeGen/bool.c
index 565188dbb77b..4b3d9abadbbf 100644
--- a/clang/test/CIR/CodeGen/bool.c
+++ b/clang/test/CIR/CodeGen/bool.c
@@ -19,7 +19,7 @@ void init_bool(void) {
 // CHECK:    [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
 // 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:    [[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:    [[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>
diff --git a/clang/test/CIR/CodeGen/builtin-alloca.c b/clang/test/CIR/CodeGen/builtin-alloca.c
index d4e7498f10d8..ee4b05976bda 100644
--- a/clang/test/CIR/CodeGen/builtin-alloca.c
+++ b/clang/test/CIR/CodeGen/builtin-alloca.c
@@ -13,7 +13,7 @@ void my_alloca(size_t n)
 // 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:       [[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-NEXT:  cir.cast bitcast [[ALLOCA_RES]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
 // CIR: }
 
 
@@ -32,7 +32,7 @@ void my___builtin_alloca(size_t n)
 // 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:       [[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-NEXT:  cir.cast bitcast [[ALLOCA_RES]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
 // CIR: }
 
 
@@ -51,7 +51,7 @@ void my__builtin_alloca_uninitialized(size_t n)
 // 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:       [[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-NEXT:  cir.cast bitcast [[ALLOCA_RES]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
 // CIR: }
 
 
diff --git a/clang/test/CIR/CodeGen/builtin-arm-exclusive.c b/clang/test/CIR/CodeGen/builtin-arm-exclusive.c
index cf426c646e33..0ccb16c2672b 100644
--- a/clang/test/CIR/CodeGen/builtin-arm-exclusive.c
+++ b/clang/test/CIR/CodeGen/builtin-arm-exclusive.c
@@ -11,17 +11,17 @@ int test_ldrex(char *addr, long long *addr64, float *addrfloat) {
   int sum = 0;
   sum += __builtin_arm_ldrex(addr);
 // CIR: [[INTRES0:%.*]] = cir.llvm.intrinsic "aarch64.ldxr" {{%[0-9]+}} : (!cir.ptr<!s8i>) -> !s64i
-// CIR: [[CAST0:%.*]] = cir.cast(integral, [[INTRES0]] : !s64i), !s8i
-// CIR: [[CAST_I32:%.*]] = cir.cast(integral, [[CAST0]] : !s8i), !s32i
+// CIR: [[CAST0:%.*]] = cir.cast integral [[INTRES0]] : !s64i -> !s8i
+// CIR: [[CAST_I32:%.*]] = cir.cast integral [[CAST0]] : !s8i -> !s32i
 
   sum += __builtin_arm_ldrex((short *)addr);
 // CIR: [[INTRES1:%.*]] = cir.llvm.intrinsic "aarch64.ldxr" {{%[0-9]+}} : (!cir.ptr<!s16i>) -> !s64i
-// CIR: [[CAST1:%.*]] = cir.cast(integral, [[INTRES1]] : !s64i), !s16i
-// CIR: [[CAST_I16:%.*]] = cir.cast(integral, [[CAST1]] : !s16i), !s32i
+// CIR: [[CAST1:%.*]] = cir.cast integral [[INTRES1]] : !s64i -> !s16i
+// CIR: [[CAST_I16:%.*]] = cir.cast integral [[CAST1]] : !s16i -> !s32i
 
   sum += __builtin_arm_ldrex((int *)addr);
 // CIR: [[INTRES2:%.*]] = cir.llvm.intrinsic "aarch64.ldxr" {{%[0-9]+}} : (!cir.ptr<!s32i>) -> !s64i
-// CIR: [[CAST2:%.*]] = cir.cast(integral, [[INTRES2]] : !s64i), !s32i
+// CIR: [[CAST2:%.*]] = cir.cast integral [[INTRES2]] : !s64i -> !s32i
 
   sum += __builtin_arm_ldrex((long long *)addr);
 // CIR: [[INTRES3:%.*]] = cir.llvm.intrinsic "aarch64.ldxr" {{%[0-9]+}} : (!cir.ptr<!s64i>) -> !s64i
@@ -35,7 +35,7 @@ int test_ldrex(char *addr, long long *addr64, float *addrfloat) {
 
   sum += __builtin_arm_ldrex((struct twoFldT **)addr)->a;
 // CIR: [[INTRES6:%.*]] = cir.llvm.intrinsic "aarch64.ldxr"  {{%[0-9]+}} : (!cir.ptr<!cir.ptr<!rec_twoFldT>>) -> !s64i
-// CIR: [[CAST3:%.*]] = cir.cast(int_to_ptr, [[INTRES6]] : !s64i), !cir.ptr<!rec_twoFldT>
+// CIR: [[CAST3:%.*]] = cir.cast int_to_ptr [[INTRES6]] : !s64i -> !cir.ptr<!rec_twoFldT>
 // CIR: [[MEMBER_A:%.*]] = cir.get_member [[CAST3]][0] {name = "a"} : !cir.ptr<!rec_twoFldT> -> !cir.ptr<!s8i>
 
 
@@ -53,17 +53,17 @@ int test_ldaex(char *addr, long long *addr64, float *addrfloat) {
   int sum = 0;
   sum += __builtin_arm_ldaex(addr);
 // CIR: [[INTRES0:%.*]] = cir.llvm.intrinsic "aarch64.ldaxr" {{%[0-9]+}} : (!cir.ptr<!s8i>) -> !s64i
-// CIR: [[CAST0:%.*]] = cir.cast(integral, [[INTRES0]] : !s64i), !s8i
-// CIR: [[CAST_I32:%.*]] = cir.cast(integral, [[CAST0]] : !s8i), !s32i
+// CIR: [[CAST0:%.*]] = cir.cast integral [[INTRES0]] : !s64i -> !s8i
+// CIR: [[CAST_I32:%.*]] = cir.cast integral [[CAST0]] : !s8i -> !s32i
 
   sum += __builtin_arm_ldaex((short *)addr);
 // CIR: [[INTRES1:%.*]] = cir.llvm.intrinsic "aarch64.ldaxr" {{%[0-9]+}} : (!cir.ptr<!s16i>) -> !s64i
-// CIR: [[CAST1:%.*]] = cir.cast(integral, [[INTRES1]] : !s64i), !s16i
-// CIR: [[CAST_I16:%.*]] = cir.cast(integral, [[CAST1]] : !s16i), !s32i
+// CIR: [[CAST1:%.*]] = cir.cast integral [[INTRES1]] : !s64i -> !s16i
+// CIR: [[CAST_I16:%.*]] = cir.cast integral [[CAST1]] : !s16i -> !s32i
 
   sum += __builtin_arm_ldaex((int *)addr);
 // CIR: [[INTRES2:%.*]] = cir.llvm.intrinsic "aarch64.ldaxr" {{%[0-9]+}} : (!cir.ptr<!s32i>) -> !s64i
-// CIR: [[CAST2:%.*]] = cir.cast(integral, [[INTRES2]] : !s64i), !s32i
+// CIR: [[CAST2:%.*]] = cir.cast integral [[INTRES2]] : !s64i -> !s32i
 
   sum += __builtin_arm_ldaex((long long *)addr);
 // CIR: [[INTRES3:%.*]] = cir.llvm.intrinsic "aarch64.ldaxr" {{%[0-9]+}} : (!cir.ptr<!s64i>) -> !s64i
@@ -77,7 +77,7 @@ int test_ldaex(char *addr, long long *addr64, float *addrfloat) {
 
   sum += __builtin_arm_ldaex((struct twoFldT **)addr)->a;
 // CIR: [[INTRES6:%.*]] = cir.llvm.intrinsic "aarch64.ldaxr"  {{%[0-9]+}} : (!cir.ptr<!cir.ptr<!rec_twoFldT>>) -> !s64i
-// CIR: [[CAST3:%.*]] = cir.cast(int_to_ptr, [[INTRES6]] : !s64i), !cir.ptr<!rec_twoFldT>
+// CIR: [[CAST3:%.*]] = cir.cast int_to_ptr [[INTRES6]] : !s64i -> !cir.ptr<!rec_twoFldT>
 // CIR: [[MEMBER_A:%.*]] = cir.get_member [[CAST3]][0] {name = "a"} : !cir.ptr<!rec_twoFldT> -> !cir.ptr<!s8i>
 
 
diff --git a/clang/test/CIR/CodeGen/builtin-assume.cpp b/clang/test/CIR/CodeGen/builtin-assume.cpp
index 04e8f2b0b7a8..9ac03c716234 100644
--- a/clang/test/CIR/CodeGen/builtin-assume.cpp
+++ b/clang/test/CIR/CodeGen/builtin-assume.cpp
@@ -61,7 +61,7 @@ int test_assume_aligned_offset(int *ptr) {
 //      CIR: cir.func dso_local @_Z26test_assume_aligned_offsetPi
 //      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:   %[[#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>
@@ -80,9 +80,9 @@ int test_separate_storage(int *p1, int *p2) {
 
 //      CIR: cir.func dso_local @_Z21test_separate_storagePiS_
 //      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:   %[[#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_voidptr:]] = cir.cast(bitcast, %[[#p2]] : !cir.ptr<!s32i>), !cir.ptr<!void>
+// 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-bcopy.cpp b/clang/test/CIR/CodeGen/builtin-bcopy.cpp
index 792fe03a59e9..5160a91ae659 100644
--- a/clang/test/CIR/CodeGen/builtin-bcopy.cpp
+++ b/clang/test/CIR/CodeGen/builtin-bcopy.cpp
@@ -7,13 +7,13 @@ void foo(void) {
   // CIR-LABEL: cir.func dso_local @_Z3foov()
   // CIR: %[[V0:.*]] = cir.alloca !cir.array<!cir.float x 4>, !cir.ptr<!cir.array<!cir.float x 4>>, ["f4"] {alignment = 16 : i64}
   // CIR: %[[V1:.*]] = cir.alloca !cir.array<!cir.float x 8>, !cir.ptr<!cir.array<!cir.float x 8>>, ["f8"] {alignment = 16 : i64}
-  // CIR: %[[V2:.*]] = cir.cast(array_to_ptrdecay, %[[V0]] : !cir.ptr<!cir.array<!cir.float x 4>>), !cir.ptr<!cir.float>
-  // CIR: %[[V3:.*]] = cir.cast(bitcast, %[[V2]] : !cir.ptr<!cir.float>), !cir.ptr<!void>
-  // CIR: %[[V4:.*]] = cir.cast(array_to_ptrdecay, %[[V1]] : !cir.ptr<!cir.array<!cir.float x 8>>), !cir.ptr<!cir.float>
-  // CIR: %[[V5:.*]] = cir.cast(bitcast, %[[V4]] : !cir.ptr<!cir.float>), !cir.ptr<!void>
+  // CIR: %[[V2:.*]] = cir.cast array_to_ptrdecay %[[V0]] : !cir.ptr<!cir.array<!cir.float x 4>> -> !cir.ptr<!cir.float>
+  // CIR: %[[V3:.*]] = cir.cast bitcast %[[V2]] : !cir.ptr<!cir.float> -> !cir.ptr<!void>
+  // CIR: %[[V4:.*]] = cir.cast array_to_ptrdecay %[[V1]] : !cir.ptr<!cir.array<!cir.float x 8>> -> !cir.ptr<!cir.float>
+  // CIR: %[[V5:.*]] = cir.cast bitcast %[[V4]] : !cir.ptr<!cir.float> -> !cir.ptr<!void>
   // CIR: %[[V6:.*]] = cir.const #cir.int<4> : !u64i
   // CIR: %[[V7:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[V8:.*]] = cir.cast(integral, %[[V7]] : !s32i), !u64i
+  // CIR: %[[V8:.*]] = cir.cast integral %[[V7]] : !s32i -> !u64i
   // CIR: %[[V9:.*]] = cir.binop(mul, %[[V6]], %[[V8]]) : !u64i
   // CIR: cir.libc.memmove %[[V9]] bytes from %[[V3]] to %[[V5]] : !cir.ptr<!void>, !u64i
   // CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/builtin-bit-cast.cpp b/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
index aeeae56d4f83..1551e7e121e9 100644
--- a/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
+++ b/clang/test/CIR/CodeGen/builtin-bit-cast.cpp
@@ -9,7 +9,7 @@ float test_scalar(int &oper) {
 
 // CIR-LABEL: cir.func dso_local @_Z11test_scalarRi
 //       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:   %[[#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: }
 
@@ -29,7 +29,7 @@ unsigned long test_aggregate_to_scalar(two_ints &ti) {
 
 // CIR-LABEL: cir.func dso_local @_Z24test_aggregate_to_scalarR8two_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:   %[[#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: }
 
@@ -49,8 +49,8 @@ two_floats test_aggregate_record(two_ints& ti) {
 
 // CIR-LABEL: cir.func dso_local @_Z21test_aggregate_recordR8two_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:   %[[#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
 //  CIR-NEXT:   cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //       CIR: }
@@ -68,8 +68,8 @@ two_floats test_aggregate_array(int (&ary)[2]) {
 
 // CIR-LABEL: cir.func dso_local @_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-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:   %[[#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
 //  CIR-NEXT:   cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //       CIR: }
@@ -86,8 +86,8 @@ two_ints test_scalar_to_aggregate(unsigned long ul) {
 }
 
 // CIR-LABEL: cir.func dso_local @_Z24test_scalar_to_aggregatem
-//       CIR:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!u64i>), !cir.ptr<!void>
-//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!rec_two_ints>), !cir.ptr<!void>
+//       CIR:   %[[#SRC_VOID_PTR:]] = cir.cast bitcast %{{.+}} : !cir.ptr<!u64i> -> !cir.ptr<!void>
+//  CIR-NEXT:   %[[#DST_VOID_PTR:]] = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_two_ints> -> !cir.ptr<!void>
 //  CIR-NEXT:   %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
 //  CIR-NEXT:   cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //       CIR: }
@@ -104,7 +104,7 @@ unsigned long test_array(int (&ary)[2]) {
 
 // CIR-LABEL: cir.func dso_local @_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-NEXT:   %[[#DST_PTR:]] = cir.cast(bitcast, %[[#SRC_PTR]] : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!u64i>
+// 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: }
 
@@ -122,8 +122,8 @@ two_ints test_rvalue_aggregate() {
 //  CIR-NEXT:     %[[#TMP_SLOT:]] = cir.alloca !u64i, !cir.ptr<!u64i>
 //  CIR-NEXT:     %[[#A:]] = cir.const #cir.int<42> : !u64i
 //  CIR-NEXT:     cir.store{{.*}} %[[#A]], %[[#TMP_SLOT]] : !u64i, !cir.ptr<!u64i>
-//  CIR-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %[[#TMP_SLOT]] : !cir.ptr<!u64i>), !cir.ptr<!void>
-//  CIR-NEXT:     %[[#DST_VOID_PTR:]] = cir.cast(bitcast, %0 : !cir.ptr<!rec_two_ints>), !cir.ptr<!void>
+//  CIR-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast bitcast %[[#TMP_SLOT]] : !cir.ptr<!u64i> -> !cir.ptr<!void>
+//  CIR-NEXT:     %[[#DST_VOID_PTR:]] = cir.cast bitcast %0 : !cir.ptr<!rec_two_ints> -> !cir.ptr<!void>
 //  CIR-NEXT:     %[[#SIZE:]] = cir.const #cir.int<8> : !u64i
 //  CIR-NEXT:     cir.libc.memcpy %[[#SIZE]] bytes from %[[#SRC_VOID_PTR]] to %[[#DST_VOID_PTR]] : !u64i, !cir.ptr<!void> -> !cir.ptr<!void>
 //  CIR-NEXT:   }
diff --git a/clang/test/CIR/CodeGen/builtin-bits.cpp b/clang/test/CIR/CodeGen/builtin-bits.cpp
index eb7c8819117e..7baa94e3edd1 100644
--- a/clang/test/CIR/CodeGen/builtin-bits.cpp
+++ b/clang/test/CIR/CodeGen/builtin-bits.cpp
@@ -14,7 +14,7 @@ int test_builtin_clrsbl(long x) {
 
 // CIR-LABEL: _Z19test_builtin_clrsbll
 // CIR: [[TMP:%.+]] = cir.clrsb %{{.+}} : !s64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !s64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !s64i -> !s32i
 
 int test_builtin_clrsbll(long long x) {
   return __builtin_clrsbll(x);
@@ -22,7 +22,7 @@ int test_builtin_clrsbll(long long x) {
 
 // CIR-LABEL: _Z20test_builtin_clrsbllx
 // CIR: [[TMP:%.+]] = cir.clrsb %{{.+}} : !s64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !s64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !s64i -> !s32i
 
 int test_builtin_ctzs(unsigned short x) {
   return __builtin_ctzs(x);
@@ -30,7 +30,7 @@ int test_builtin_ctzs(unsigned short x) {
 
 // CIR-LABEL: _Z17test_builtin_ctzst
 // CIR: [[TMP:%.+]] = cir.ctz %{{.+}} zero_poison : !u16i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u16i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u16i -> !s32i
 
 int test_builtin_ctz(unsigned x) {
   return __builtin_ctz(x);
@@ -38,7 +38,7 @@ int test_builtin_ctz(unsigned x) {
 
 // CIR-LABEL: _Z16test_builtin_ctzj
 // CIR: [[TMP:%.+]] = cir.ctz %{{.+}} zero_poison : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
 
 int test_builtin_ctzl(unsigned long x) {
   return __builtin_ctzl(x);
@@ -46,7 +46,7 @@ int test_builtin_ctzl(unsigned long x) {
 
 // CIR-LABEL: _Z17test_builtin_ctzlm
 // CIR: [[TMP:%.+]] = cir.ctz %{{.+}} zero_poison : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_ctzll(unsigned long long x) {
   return __builtin_ctzll(x);
@@ -54,7 +54,7 @@ int test_builtin_ctzll(unsigned long long x) {
 
 // CIR-LABEL: _Z18test_builtin_ctzlly
 // CIR: [[TMP:%.+]] = cir.ctz %{{.+}} zero_poison : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_ctzg(unsigned x) {
   return __builtin_ctzg(x);
@@ -62,7 +62,7 @@ int test_builtin_ctzg(unsigned x) {
 
 // CIR-LABEL: _Z17test_builtin_ctzgj
 // CIR: [[TMP:%.+]] = cir.ctz %{{.+}} zero_poison : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
 
 int test_builtin_clzs(unsigned short x) {
   return __builtin_clzs(x);
@@ -70,7 +70,7 @@ int test_builtin_clzs(unsigned short x) {
 
 // CIR-LABEL: _Z17test_builtin_clzst
 // CIR: [[TMP:%.+]] = cir.clz %{{.+}} zero_poison : !u16i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u16i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u16i -> !s32i
 
 int test_builtin_clz(unsigned x) {
   return __builtin_clz(x);
@@ -78,7 +78,7 @@ int test_builtin_clz(unsigned x) {
 
 // CIR-LABEL: _Z16test_builtin_clzj
 // CIR: [[TMP:%.+]] = cir.clz %{{.+}} zero_poison : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
 
 int test_builtin_clzl(unsigned long x) {
   return __builtin_clzl(x);
@@ -86,7 +86,7 @@ int test_builtin_clzl(unsigned long x) {
 
 // CIR-LABEL: _Z17test_builtin_clzlm
 // CIR: [[TMP:%.+]] = cir.clz %{{.+}} zero_poison : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_clzll(unsigned long long x) {
   return __builtin_clzll(x);
@@ -94,7 +94,7 @@ int test_builtin_clzll(unsigned long long x) {
 
 // CIR-LABEL: _Z18test_builtin_clzlly
 // CIR: [[TMP:%.+]] = cir.clz %{{.+}} zero_poison : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_clzg(unsigned x) {
   return __builtin_clzg(x);
@@ -102,7 +102,7 @@ int test_builtin_clzg(unsigned x) {
 
 // CIR-LABEL: _Z17test_builtin_clzgj
 // CIR: [[TMP:%.+]] = cir.clz %{{.+}} zero_poison : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
 
 int test_builtin_ffs(int x) {
   return __builtin_ffs(x);
@@ -117,7 +117,7 @@ int test_builtin_ffsl(long x) {
 
 // CIR-LABEL: _Z17test_builtin_ffsll
 // CIR: [[TMP:%.+]] = cir.ffs %{{.+}} : !s64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !s64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !s64i -> !s32i
 
 int test_builtin_ffsll(long long x) {
   return __builtin_ffsll(x);
@@ -125,7 +125,7 @@ int test_builtin_ffsll(long long x) {
 
 // CIR-LABEL: _Z18test_builtin_ffsllx
 // CIR: [[TMP:%.+]] = cir.ffs %{{.+}} : !s64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !s64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !s64i -> !s32i
 
 int test_builtin_parity(unsigned x) {
   return __builtin_parity(x);
@@ -133,7 +133,7 @@ int test_builtin_parity(unsigned x) {
 
 // CIR-LABEL: _Z19test_builtin_parityj
 // CIR: [[TMP:%.+]] = cir.parity %{{.+}} : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
 
 int test_builtin_parityl(unsigned long x) {
   return __builtin_parityl(x);
@@ -141,7 +141,7 @@ int test_builtin_parityl(unsigned long x) {
 
 // CIR-LABEL: _Z20test_builtin_paritylm
 // CIR: [[TMP:%.+]] = cir.parity %{{.+}} : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_parityll(unsigned long long x) {
   return __builtin_parityll(x);
@@ -149,7 +149,7 @@ int test_builtin_parityll(unsigned long long x) {
 
 // CIR-LABEL: _Z21test_builtin_paritylly
 // CIR: [[TMP:%.+]] = cir.parity %{{.+}} : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_popcount(unsigned x) {
   return __builtin_popcount(x);
@@ -157,7 +157,7 @@ int test_builtin_popcount(unsigned x) {
 
 // CIR-LABEL: _Z21test_builtin_popcountj
 // CIR: [[TMP:%.+]] = cir.popcount %{{.+}} : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
 
 int test_builtin_popcountl(unsigned long x) {
   return __builtin_popcountl(x);
@@ -165,7 +165,7 @@ int test_builtin_popcountl(unsigned long x) {
 
 // CIR-LABEL: _Z22test_builtin_popcountlm
 // CIR: [[TMP:%.+]] = cir.popcount %{{.+}} : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_popcountll(unsigned long long x) {
   return __builtin_popcountll(x);
@@ -173,7 +173,7 @@ int test_builtin_popcountll(unsigned long long x) {
 
 // CIR-LABEL: _Z23test_builtin_popcountlly
 // CIR: [[TMP:%.+]] = cir.popcount %{{.+}} : !u64i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u64i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u64i -> !s32i
 
 int test_builtin_popcountg(unsigned x) {
   return __builtin_popcountg(x);
@@ -181,4 +181,4 @@ int test_builtin_popcountg(unsigned x) {
 
 // CIR-LABEL: _Z22test_builtin_popcountgj
 // CIR: [[TMP:%.+]] = cir.popcount %{{.+}} : !u32i
-// CIR: {{%.+}} = cir.cast(integral, [[TMP]] : !u32i), !s32i
+// CIR: {{%.+}} = cir.cast integral [[TMP]] : !u32i -> !s32i
diff --git a/clang/test/CIR/CodeGen/builtin-constant-p.c b/clang/test/CIR/CodeGen/builtin-constant-p.c
index 58c071b16f16..6abcbeea505e 100644
--- a/clang/test/CIR/CodeGen/builtin-constant-p.c
+++ b/clang/test/CIR/CodeGen/builtin-constant-p.c
@@ -11,7 +11,7 @@ int foo() {
 // CIR:    [[TMP1:%.*]] = cir.get_global @a : !cir.ptr<!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:    [[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:    cir.return [[TMP5]] : !s32i
diff --git a/clang/test/CIR/CodeGen/builtin-fcmp-sse.c b/clang/test/CIR/CodeGen/builtin-fcmp-sse.c
index d99d2c4adcfd..b232f8515a89 100644
--- a/clang/test/CIR/CodeGen/builtin-fcmp-sse.c
+++ b/clang/test/CIR/CodeGen/builtin-fcmp-sse.c
@@ -9,7 +9,7 @@ __m128 test_cmpnleps(__m128 A, __m128 B) {
   // CIR-LABEL: @test_cmpnleps
   // CIR: [[CMP:%.*]] = cir.vec.cmp(le, [[A:%.*]], [[B:%.*]]) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
   // CIR: [[NOTCMP:%.*]] = cir.unary(not, [[CMP]]) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
-  // CIR-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[NOTCMP:%.*]] : !cir.vector<!s32i x 4>), !cir.vector<!cir.float x 4>
+  // CIR-NEXT: [[CAST:%.*]] = cir.cast bitcast [[NOTCMP:%.*]] : !cir.vector<!s32i x 4> -> !cir.vector<!cir.float x 4>
   // CIR-NEXT: cir.store [[CAST]], [[ALLOCA:%.*]] :  !cir.vector<!cir.float x 4>, !cir.ptr<!cir.vector<!cir.float x 4>>
   // CIR-NEXT: [[LD:%.*]] = cir.load [[ALLOCA]] :
   // CIR-NEXT: cir.return [[LD]] : !cir.vector<!cir.float x 4>
@@ -33,7 +33,7 @@ __m128d test_cmpnlepd(__m128d A, __m128d B) {
   // CIR-LABEL: @test_cmpnlepd
   // CIR: [[CMP:%.*]] = cir.vec.cmp(le, [[A:%.*]], [[B:%.*]]) :  !cir.vector<!cir.double x 2>, !cir.vector<!s64i x 2>
   // CIR-NEXT: [[NOTCMP:%.*]] = cir.unary(not, [[CMP]]) : !cir.vector<!s64i x 2>, !cir.vector<!s64i x 2>
-  // CIR-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[NOTCMP]] :  !cir.vector<!s64i x 2>), !cir.vector<!cir.double x 2>
+  // CIR-NEXT: [[CAST:%.*]] = cir.cast bitcast [[NOTCMP]] :  !cir.vector<!s64i x 2> -> !cir.vector<!cir.double x 2>
   // CIR-NEXT: cir.store [[CAST]], [[ALLOCA:%.*]] : !cir.vector<!cir.double x 2>, !cir.ptr<!cir.vector<!cir.double x 2>>
   // CIR-NEXT: [[LD:%.*]] = cir.load [[ALLOCA]] :
   // CIR-NEXT: cir.return [[LD]] : !cir.vector<!cir.double x 2>
@@ -57,7 +57,7 @@ __m128 test_cmpnltps(__m128 A, __m128 B) {
   // CIR-LABEL: @test_cmpnltps
   // CIR: [[CMP:%.*]] = cir.vec.cmp(lt, [[A:%.*]], [[B:%.*]]) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
   // CIR: [[NOTCMP:%.*]] = cir.unary(not, [[CMP]]) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
-  // CIR-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[NOTCMP:%.*]] : !cir.vector<!s32i x 4>), !cir.vector<!cir.float x 4>
+  // CIR-NEXT: [[CAST:%.*]] = cir.cast bitcast [[NOTCMP:%.*]] : !cir.vector<!s32i x 4> -> !cir.vector<!cir.float x 4>
   // CIR-NEXT: cir.store [[CAST]], [[ALLOCA:%.*]] :  !cir.vector<!cir.float x 4>, !cir.ptr<!cir.vector<!cir.float x 4>>
   // CIR-NEXT: [[LD:%.*]] = cir.load [[ALLOCA]] :
   // CIR-NEXT: cir.return [[LD]] : !cir.vector<!cir.float x 4>
@@ -81,7 +81,7 @@ __m128d test_cmpnltpd(__m128d A, __m128d B) {
   // CIR-LABEL: @test_cmpnltpd
   // CIR: [[CMP:%.*]] = cir.vec.cmp(lt, [[A:%.*]], [[B:%.*]]) :  !cir.vector<!cir.double x 2>, !cir.vector<!s64i x 2>
   // CIR-NEXT: [[NOTCMP:%.*]] = cir.unary(not, [[CMP]]) : !cir.vector<!s64i x 2>, !cir.vector<!s64i x 2>
-  // CIR-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[NOTCMP]] :  !cir.vector<!s64i x 2>), !cir.vector<!cir.double x 2>
+  // CIR-NEXT: [[CAST:%.*]] = cir.cast bitcast [[NOTCMP]] :  !cir.vector<!s64i x 2> -> !cir.vector<!cir.double x 2>
   // CIR-NEXT: cir.store [[CAST]], [[ALLOCA:%.*]] : !cir.vector<!cir.double x 2>, !cir.ptr<!cir.vector<!cir.double x 2>>
   // CIR-NEXT: [[LD:%.*]] = cir.load [[ALLOCA]] :
   // CIR-NEXT: cir.return [[LD]] : !cir.vector<!cir.double x 2>
diff --git a/clang/test/CIR/CodeGen/builtin-ms-alloca.c b/clang/test/CIR/CodeGen/builtin-ms-alloca.c
index 20cada4c43ea..c281ef298743 100644
--- a/clang/test/CIR/CodeGen/builtin-ms-alloca.c
+++ b/clang/test/CIR/CodeGen/builtin-ms-alloca.c
@@ -12,7 +12,7 @@ void my_win_alloca(size_t n)
 // 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:       [[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-NEXT:  cir.cast bitcast [[ALLOCA_RES]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
 // CIR: }
 
 
diff --git a/clang/test/CIR/CodeGen/builtin-rotate.c b/clang/test/CIR/CodeGen/builtin-rotate.c
index bc0c93690658..85aa6be13ebf 100644
--- a/clang/test/CIR/CodeGen/builtin-rotate.c
+++ b/clang/test/CIR/CodeGen/builtin-rotate.c
@@ -9,7 +9,7 @@ void f() {
   unsigned int v[4];
   unsigned int h = __builtin_rotateleft32(v[0], 1);
 // CIR: %[[CONST:.*]] = cir.const #cir.int<1> : !s32i
-// CIR: %[[CAST:.*]] = cir.cast(integral, %[[CONST]] : !s32i), !u32i
+// CIR: %[[CAST:.*]] = cir.cast integral %[[CONST]] : !s32i -> !u32i
 // CIR: cir.rotate left {{.*}}, %[[CAST]] -> !u32i
 
 // LLVM: %[[SRC:.*]] = load i32, ptr
diff --git a/clang/test/CIR/CodeGen/builtin-setjmp-longjmp.c b/clang/test/CIR/CodeGen/builtin-setjmp-longjmp.c
index a0ff6792ef58..b63f3a75da5a 100644
--- a/clang/test/CIR/CodeGen/builtin-setjmp-longjmp.c
+++ b/clang/test/CIR/CodeGen/builtin-setjmp-longjmp.c
@@ -10,7 +10,7 @@ void test_setjmp(void *env) {
   // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>,
   // CIR-NEXT: cir.store [[ENV]], [[ENV_ALLOCA]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
   // CIR-NEXT: [[ENV_LOAD:%[0-9]+]] = cir.load align(8) [[ENV_ALLOCA]]
-  // CIR-NEXT: [[CAST:%[0-9]+]] = cir.cast(bitcast, [[ENV_LOAD]] : !cir.ptr<!void>), !cir.ptr<!cir.ptr<!void>>
+  // CIR-NEXT: [[CAST:%[0-9]+]] = cir.cast bitcast [[ENV_LOAD]] : !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
   // CIR-NEXT: [[ZERO:%[0-9]+]] = cir.const #cir.int<0>
   // CIR-NEXT: [[FA:%[0-9]+]] = cir.frame_address([[ZERO]])
   // CIR-NEXT: cir.store [[FA]], [[CAST]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
@@ -48,7 +48,7 @@ void test_setjmp2(void *env) {
   // CIR-NEXT: [[ENV_ALLOCA]] = cir.alloca
   // CIR-NEXT: cir.store [[ENV]], [[ENV_ALLOCA]]
   // CIR-NEXT: [[ENV_LOAD:%.*]] = cir.load align(8) [[ENV_ALLOCA]]
-  // CIR-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[ENV_LOAD]]
+  // CIR-NEXT: [[CAST:%.*]] = cir.cast bitcast [[ENV_LOAD]]
   // CIR-NEXT: cir.eh.setjmp [[CAST]] : (!cir.ptr<!cir.ptr<!void>>) -> !s32i
 
 
diff --git a/clang/test/CIR/CodeGen/builtins-memory.c b/clang/test/CIR/CodeGen/builtins-memory.c
index 85ff19d800ef..0a21835ea844 100644
--- a/clang/test/CIR/CodeGen/builtins-memory.c
+++ b/clang/test/CIR/CodeGen/builtins-memory.c
@@ -238,9 +238,9 @@ void* test_builtin_mempcpy(void *dest, void *src, size_t n) {
   // CIR-LABEL: test_builtin_mempcpy
   // CIR: [[ALLOCA:%.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"]
   // CIR: cir.libc.memcpy [[NUM:%.*]] bytes from [[S:.*]] to [[DST:.*]] :
-  // CIR: [[CAST2:%.*]] = cir.cast(bitcast, [[DST]] : !cir.ptr<!void>), !cir.ptr<!cir.ptr<!u8i>>
+  // CIR: [[CAST2:%.*]] = cir.cast bitcast [[DST]] : !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!u8i>>
   // CIR: [[GEP:%.*]] = cir.ptr_stride [[CAST2]], [[NUM]] : (!cir.ptr<!cir.ptr<!u8i>>, !u64i) -> !cir.ptr<!cir.ptr<!u8i>>
-  // CIR: [[CAST3:%.*]] = cir.cast(bitcast, [[ALLOCA]]
+  // CIR: [[CAST3:%.*]] = cir.cast bitcast [[ALLOCA]]
   // CIR: cir.store [[GEP]], [[CAST3:%.*]]
   // CIR-NEXT: [[LD:%.*]] = cir.load [[ALLOCA]]
   // CIR-NEXT: cir.return [[LD]]
diff --git a/clang/test/CIR/CodeGen/builtins-overflow.cpp b/clang/test/CIR/CodeGen/builtins-overflow.cpp
index a4513cf71add..8cd227d58686 100644
--- a/clang/test/CIR/CodeGen/builtins-overflow.cpp
+++ b/clang/test/CIR/CodeGen/builtins-overflow.cpp
@@ -129,8 +129,8 @@ bool test_add_overflow_uint_int_int(unsigned x, int y, int *res) {
 //      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:   %[[#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)
 // CIR-NEXT:   cir.store{{.*}} %[[RES]], %[[#RES_PTR]] : !s32i, !cir.ptr<!s32i>
 //      CIR: }
diff --git a/clang/test/CIR/CodeGen/builtins.cpp b/clang/test/CIR/CodeGen/builtins.cpp
index 504ec13da6ee..96fe32e8e8bd 100644
--- a/clang/test/CIR/CodeGen/builtins.cpp
+++ b/clang/test/CIR/CodeGen/builtins.cpp
@@ -63,7 +63,7 @@ extern "C" char* test_memchr(const char arg[32]) {
   // CIR-LABEL: test_memchr
   // CIR: [[PATTERN:%.*]] = cir.const #cir.int<123> : !s32i 
   // CIR: [[LEN:%.*]] = cir.const #cir.int<32> : !s32i 
-  // CIR: [[LEN_U64:%.*]] = cir.cast(integral, [[LEN]] : !s32i), !u64i 
+  // CIR: [[LEN_U64:%.*]] = cir.cast integral [[LEN]] : !s32i -> !u64i 
   // CIR: {{%.*}} = cir.libc.memchr({{%.*}}, [[PATTERN]], [[LEN_U64]])
 
   // LLVM: {{.*}}@test_memchr(ptr{{.*}}[[ARG:%.*]]) 
@@ -82,7 +82,7 @@ extern "C"  wchar_t* test_wmemchr(const wchar_t *wc) {
   // CIR-LABEL: test_wmemchr
   // CIR: [[PATTERN:%.*]] = cir.const #cir.int<257> : !u32i 
   // CIR: [[LEN:%.*]] = cir.const #cir.int<32> : !s32i 
-  // CIR: [[LEN_U64:%.*]] = cir.cast(integral, [[LEN]] : !s32i), !u64i 
+  // CIR: [[LEN_U64:%.*]] = cir.cast integral [[LEN]] : !s32i -> !u64i 
   // CIR: cir.call @wmemchr({{%.*}}, [[PATTERN]], [[LEN_U64]]) : (!cir.ptr<!u32i>, !u32i, !u64i) -> !cir.ptr<!u32i>
 
   // LLVM: {{.*}}@test_wmemchr(ptr{{.*}}[[ARG:%.*]])
diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp
index 4d7e23a22329..4f96674489b9 100644
--- a/clang/test/CIR/CodeGen/cast.cpp
+++ b/clang/test/CIR/CodeGen/cast.cpp
@@ -10,7 +10,7 @@ unsigned char cxxstaticcast_0(unsigned int x) {
 // 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:    %3 = cir.cast(integral, %2 : !u32i), !u8i
+// 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:    cir.return %4 : !u8i
@@ -21,67 +21,67 @@ int cStyleCasts_0(unsigned x1, int x2, float x3, short x4, double x5) {
 // CHECK: cir.func dso_local @_{{.*}}cStyleCasts_0{{.*}}
 
   char a = (char)x1; // truncate
-  // CHECK: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !u32i), !s8i
+  // CHECK: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !u32i -> !s8i
 
   short b = (short)x2; // truncate with sign
-  // CHECK: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !s32i), !s16i
+  // CHECK: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !s32i -> !s16i
 
   long long c = (long long)x1; // zero extend
-  // CHECK: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !u32i), !s64i
+  // CHECK: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !u32i -> !s64i
 
   long long d = (long long)x2; // sign extend
-  // CHECK: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !s32i), !s64i
+  // CHECK: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !s32i -> !s64i
 
   unsigned ui = (unsigned)x2; // sign drop
-  // CHECK: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !s32i), !u32i
+  // CHECK: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !s32i -> !u32i
 
   int si = (int)x1; // sign add
-  // CHECK: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !u32i), !s32i
+  // CHECK: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !u32i -> !s32i
 
   unsigned uu = (unsigned)x1; // should not be generated
-  // CHECK-NOT: %{{[0-9]+}} = cir.cast(integral, %{{[0-9]+}} : !u32i), !u32i
+  // CHECK-NOT: %{{[0-9]+}} = cir.cast integral %{{[0-9]+}} : !u32i -> !u32i
 
   int arr[3];
   int* e = (int*)arr; // explicit pointer decay
-  // CHECK: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %{{[0-9]+}} : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
+  // CHECK: %{{[0-9]+}} = cir.cast array_to_ptrdecay %{{[0-9]+}} : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
 
   int f = (int)x3;
-  // CHECK: %{{[0-9]+}} = cir.cast(float_to_int, %{{[0-9]+}} : !cir.float), !s32i
+  // CHECK: %{{[0-9]+}} = cir.cast float_to_int %{{[0-9]+}} : !cir.float -> !s32i
 
   double g = (double)x3; // FP extension
-  // %{{[0-9]+}} = cir.cast(floating, %{{[0-9]+}} : !cir.float), !cir.double
+  // %{{[0-9]+}} = cir.cast floating %{{[0-9]+}} : !cir.float -> !cir.double
 
   long l = (long)(void*)x4; // Must sign extend before casting to pointer
-  // CHECK: %[[TMP:[0-9]+]] = cir.cast(integral, %{{[0-9]+}} : !s16i), !u64i
-  // CHECK: %[[TMP2:[0-9]+]] = cir.cast(int_to_ptr, %[[TMP]] : !u64i), !cir.ptr<!void>
-  // CHECK: %{{[0-9]+}} = cir.cast(ptr_to_int, %[[TMP2]] : !cir.ptr<!void>), !s64i
+  // CHECK: %[[TMP:[0-9]+]] = cir.cast integral %{{[0-9]+}} : !s16i -> !u64i
+  // CHECK: %[[TMP2:[0-9]+]] = cir.cast int_to_ptr %[[TMP]] : !u64i -> !cir.ptr<!void>
+  // CHECK: %{{[0-9]+}} = cir.cast ptr_to_int %[[TMP2]] : !cir.ptr<!void> -> !s64i
 
   float sitofp = (float)x2; // Signed integer to floating point
-  // CHECK: %{{.+}} = cir.cast(int_to_float, %{{[0-9]+}} : !s32i), !cir.float
+  // CHECK: %{{.+}} = cir.cast int_to_float %{{[0-9]+}} : !s32i -> !cir.float
 
   float uitofp = (float)x1; // Unsigned integer to floating point
-  // CHECK: %{{.+}} = cir.cast(int_to_float, %{{[0-9]+}} : !u32i), !cir.float
+  // CHECK: %{{.+}} = cir.cast int_to_float %{{[0-9]+}} : !u32i -> !cir.float
 
   int fptosi = (int)x3; // Floating point to signed integer
-  // CHECK: %{{.+}} = cir.cast(float_to_int, %{{[0-9]+}} : !cir.float), !s32i
+  // CHECK: %{{.+}} = cir.cast float_to_int %{{[0-9]+}} : !cir.float -> !s32i
 
   unsigned fptoui = (unsigned)x3; // Floating point to unsigned integer
-  // CHECK: %{{.+}} = cir.cast(float_to_int, %{{[0-9]+}} : !cir.float), !u32i
+  // CHECK: %{{.+}} = cir.cast float_to_int %{{[0-9]+}} : !cir.float -> !u32i
 
   bool ib = (bool)x1; // No checking, because this isn't a regular cast.
 
   int bi = (int)ib; // bool to int
-  // CHECK: %{{[0-9]+}} = cir.cast(bool_to_int, %{{[0-9]+}} : !cir.bool), !s32i
+  // CHECK: %{{[0-9]+}} = cir.cast bool_to_int %{{[0-9]+}} : !cir.bool -> !s32i
 
   float bf = (float)ib; // bool to float
-  // CHECK: %{{[0-9]+}} = cir.cast(bool_to_float, %{{[0-9]+}} : !cir.bool), !cir.float
+  // CHECK: %{{[0-9]+}} = cir.cast bool_to_float %{{[0-9]+}} : !cir.bool -> !cir.float
 
   void* bpv = (void*)ib; // bool to pointer, which is done in two steps
-  // CHECK: %[[TMP:[0-9]+]] = cir.cast(bool_to_int,  %{{[0-9]+}} : !cir.bool), !u64i
-  // CHECK: %{{[0-9]+}} = cir.cast(int_to_ptr, %[[TMP]] : !u64i), !cir.ptr<!void>
+  // CHECK: %[[TMP:[0-9]+]] = cir.cast bool_to_int  %{{[0-9]+}} : !cir.bool -> !u64i
+  // CHECK: %{{[0-9]+}} = cir.cast int_to_ptr %[[TMP]] : !u64i -> !cir.ptr<!void>
 
   float dptofp = (float)x5;
-  // CHECK: %{{.+}} = cir.cast(floating, %{{[0-9]+}} : !cir.double), !cir.float
+  // CHECK: %{{.+}} = cir.cast floating %{{[0-9]+}} : !cir.double -> !cir.float
 
   return 0;
 }
@@ -95,7 +95,7 @@ bool cptr(void *d) {
 // 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:   %4 = cir.cast(ptr_to_bool, %3 : !cir.ptr<!void>), !cir.bool
+// CHECK:   %4 = cir.cast ptr_to_bool %3 : !cir.ptr<!void> -> !cir.bool
 
 void call_cptr(void *d) {
   if (!cptr(d)) {
@@ -138,6 +138,6 @@ void int_cast(long ptr) {
 }
 
 // CHECK: cir.func dso_local @_Z8int_castl
-// CHECK:   %[[BASE:[0-9]+]] = cir.cast(int_to_ptr, %{{[0-9]+}} : !u64i), !cir.ptr<!rec_A>
+// CHECK:   %[[BASE:[0-9]+]] = cir.cast int_to_ptr %{{[0-9]+}} : !u64i -> !cir.ptr<!rec_A>
 // CHECK:   %[[FIELD:[0-9]+]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!rec_A> -> !cir.ptr<!s32i>
 // CHECK:   cir.store{{.*}} %{{[0-9]+}}, %[[FIELD]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/clear_cache.c b/clang/test/CIR/CodeGen/clear_cache.c
index eaf49f28ee21..b4123a6f9b5f 100644
--- a/clang/test/CIR/CodeGen/clear_cache.c
+++ b/clang/test/CIR/CodeGen/clear_cache.c
@@ -10,12 +10,12 @@ char buffer[32] = "This is a largely unused buffer";
 
 // CIR-LABEL: main
 // CIR:  %[[VAL_1:.*]] = cir.get_global @buffer : !cir.ptr<!cir.array<!s8i x 32>>
-// CIR:  %[[VAL_2:.*]] = cir.cast(array_to_ptrdecay, %[[VAL_1]] : !cir.ptr<!cir.array<!s8i x 32>>), !cir.ptr<!s8i>
-// CIR:  %[[VAL_3:.*]] = cir.cast(bitcast, %[[VAL_2]] : !cir.ptr<!s8i>), !cir.ptr<!void>
+// CIR:  %[[VAL_2:.*]] = cir.cast array_to_ptrdecay %[[VAL_1]] : !cir.ptr<!cir.array<!s8i x 32>> -> !cir.ptr<!s8i>
+// CIR:  %[[VAL_3:.*]] = cir.cast bitcast %[[VAL_2]] : !cir.ptr<!s8i> -> !cir.ptr<!void>
 // CIR:  %[[VAL_4:.*]] = cir.get_global @buffer : !cir.ptr<!cir.array<!s8i x 32>>
 // CIR:  %[[VAL_6:.*]] = cir.const #cir.int<32> : !s32i
 // CIR:  %[[VAL_7:.*]] = cir.get_element %[[VAL_4]][%[[VAL_6]]] : (!cir.ptr<!cir.array<!s8i x 32>>, !s32i) -> !cir.ptr<!s8i>
-// CIR:  %[[VAL_8:.*]] = cir.cast(bitcast, %[[VAL_7]] : !cir.ptr<!s8i>), !cir.ptr<!void>
+// CIR:  %[[VAL_8:.*]] = cir.cast bitcast %[[VAL_7]] : !cir.ptr<!s8i> -> !cir.ptr<!void>
 // CIR:  cir.clear_cache %[[VAL_3]] : !cir.ptr<!void>, %[[VAL_8]],
 
 // LLVM-LABEL: main
diff --git a/clang/test/CIR/CodeGen/complex-arithmetic.c b/clang/test/CIR/CodeGen/complex-arithmetic.c
index 837263d23702..5e7b125e8e09 100644
--- a/clang/test/CIR/CodeGen/complex-arithmetic.c
+++ b/clang/test/CIR/CodeGen/complex-arithmetic.c
@@ -597,14 +597,14 @@ void add_assign_float16() {
 // CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
 // CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!cir.f16> -> !cir.f16
 // CIR: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] : !cir.complex<!cir.f16> -> !cir.f16
-// CIR: %[[B_REAL_F32:.*]] = cir.cast(floating, %[[B_REAL]] : !cir.f16), !cir.float
-// CIR: %[[B_IMAG_F32:.*]] = cir.cast(floating, %[[B_IMAG]] : !cir.f16), !cir.float
+// CIR: %[[B_REAL_F32:.*]] = cir.cast floating %[[B_REAL]] : !cir.f16 -> !cir.float
+// CIR: %[[B_IMAG_F32:.*]] = cir.cast floating %[[B_IMAG]] : !cir.f16 -> !cir.float
 // CIR: %[[B_F32_COMPLEX:.*]] = cir.complex.create %[[B_REAL_F32]], %[[B_IMAG_F32]] : !cir.float -> !cir.complex<!cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
 // CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
 // CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
-// CIR: %[[A_REAL_F32:.*]] = cir.cast(floating, %[[A_REAL]] : !cir.f16), !cir.float
-// CIR: %[[A_IMAG_F32:.*]] = cir.cast(floating, %[[A_IMAG]] : !cir.f16), !cir.float
+// CIR: %[[A_REAL_F32:.*]] = cir.cast floating %[[A_REAL]] : !cir.f16 -> !cir.float
+// CIR: %[[A_IMAG_F32:.*]] = cir.cast floating %[[A_IMAG]] : !cir.f16 -> !cir.float
 // CIR: %[[A_F32_COMPLEX:.*]] = cir.complex.create %[[A_REAL_F32]], %[[A_IMAG_F32]] : !cir.float -> !cir.complex<!cir.float>
 // CIR: %[[A_F32_REAL:.*]] = cir.complex.real %[[A_F32_COMPLEX]] : !cir.complex<!cir.float> -> !cir.float
 // CIR: %[[A_F32_IMAG:.*]] = cir.complex.imag %[[A_F32_COMPLEX]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex-cast.c b/clang/test/CIR/CodeGen/complex-cast.c
index 521262569444..a9d67a17795b 100644
--- a/clang/test/CIR/CodeGen/complex-cast.c
+++ b/clang/test/CIR/CodeGen/complex-cast.c
@@ -22,31 +22,31 @@ void scalar_to_complex() {
 
 // CHECK-LABEL: @scalar_to_complex()
 
-// CIR-BEFORE: %{{.+}} = cir.cast(float_to_complex, %{{.+}} : !cir.double), !cir.complex<!cir.double>
+// 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-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-BEFORE: %{{.+}} = cir.cast int_to_complex %{{.+}} : !s32i -> !cir.complex<!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-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-NEXT: %[[#REAL:]] = cir.cast(int_to_float, %[[#A]] : !s32i), !cir.double
+// 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>
 
-//      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-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-NEXT: %[[#REAL:]] = cir.cast(float_to_int, %[[#A]] : !cir.double), !s32i
+// 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>
 
@@ -79,7 +79,7 @@ void scalar_to_complex_explicit() {
 
 // CHECK-LABEL: @scalar_to_complex_explicit()
 
-// CIR-BEFORE: %{{.+}} = cir.cast(float_to_complex, %{{.+}} : !cir.double), !cir.complex<!cir.double>
+// CIR-BEFORE: %{{.+}} = cir.cast float_to_complex %{{.+}} : !cir.double -> !cir.complex<!cir.double>
 
 //      CIR-AFTER: %[[#IMAG:]] = cir.const #cir.fp<0.000000e+00> : !cir.double
 // CIR-AFTER-NEXT: %{{.+}} = cir.complex.create %{{.+}}, %[[#IMAG]] : !cir.double -> !cir.complex<!cir.double>
@@ -87,7 +87,7 @@ void scalar_to_complex_explicit() {
 //      LLVM: %[[#A:]] = insertvalue { double, double } {{.*}}, double %{{.+}}, 0
 // LLVM-NEXT: %{{.+}} = insertvalue { double, double } %[[#A]], double 0.000000e+00, 1
 
-// CIR-BEFORE: %{{.+}} = cir.cast(int_to_complex, %{{.+}} : !s32i), !cir.complex<!s32i>
+// CIR-BEFORE: %{{.+}} = cir.cast int_to_complex %{{.+}} : !s32i -> !cir.complex<!s32i>
 
 //      CIR-AFTER: %[[#IMAG:]] = cir.const #cir.int<0> : !s32i
 // CIR-AFTER-NEXT: %{{.+}} = cir.complex.create %{{.+}}, %[[#IMAG]] : !s32i -> !cir.complex<!s32i>
@@ -95,10 +95,10 @@ void scalar_to_complex_explicit() {
 //      LLVM: %[[#A:]] = insertvalue { i32, i32 } {{.*}}, i32 %{{.+}}, 0
 // LLVM-NEXT: %{{.+}} = insertvalue { i32, i32 } %[[#A]], i32 0, 1
 
-//      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-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: %[[#REAL:]] = cir.cast(int_to_float, %11 : !s32i), !cir.double
+//      CIR-AFTER: %[[#REAL:]] = cir.cast int_to_float %11 : !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>
 
@@ -106,10 +106,10 @@ void scalar_to_complex_explicit() {
 // LLVM-NEXT: %[[#A:]] = insertvalue { double, double } {{.*}}, double %[[#REAL]], 0
 // LLVM-NEXT: %{{.+}} = insertvalue { double, double } %[[#A]], double 0.000000e+00, 1
 
-//      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-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: %[[#REAL:]] = cir.cast(float_to_int, %{{.+}} : !cir.double), !s32i
+//      CIR-AFTER: %[[#REAL:]] = cir.cast float_to_int %{{.+}} : !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>
 
@@ -128,32 +128,32 @@ void complex_to_scalar() {
 
 // CHECK-LABEL: @complex_to_scalar()
 
-// CIR-BEFORE: %{{.+}} = cir.cast(float_complex_to_real, %{{.+}} : !cir.complex<!cir.double>), !cir.double
+// CIR-BEFORE: %{{.+}} = cir.cast float_complex_to_real %{{.+}} : !cir.complex<!cir.double> -> !cir.double
 
 // CIR-AFTER: %{{.+}} = cir.complex.real %{{.+}} : !cir.complex<!cir.double> -> !cir.double
 
 // LLVM: %{{.+}} = extractvalue { double, double } %{{.+}}, 0
 
-// CIR-BEFORE: %{{.+}} = cir.cast(int_complex_to_real, %{{.+}} : !cir.complex<!s32i>), !s32i
+// CIR-BEFORE: %{{.+}} = cir.cast int_complex_to_real %{{.+}} : !cir.complex<!s32i> -> !s32i
 
 // CIR-AFTER: %{{.+}} = cir.complex.real %{{.+}} : !cir.complex<!s32i> -> !s32i
 
 // LLVM: %{{.+}} = extractvalue { i32, i32 } %{{.+}}, 0
 
-//      CIR-BEFORE: %[[#A:]] = cir.cast(int_complex_to_real, %{{.+}} : !cir.complex<!s32i>), !s32i
-// CIR-BEFORE-NEXT: %{{.+}} = cir.cast(int_to_float, %[[#A]] : !s32i), !cir.double
+//      CIR-BEFORE: %[[#A:]] = cir.cast int_complex_to_real %{{.+}} : !cir.complex<!s32i> -> !s32i
+// CIR-BEFORE-NEXT: %{{.+}} = cir.cast int_to_float %[[#A]] : !s32i -> !cir.double
 
 //      CIR-AFTER: %[[#A:]] = cir.complex.real %{{.+}} : !cir.complex<!s32i> -> !s32i
-// CIR-AFTER-NEXT: %{{.+}} = cir.cast(int_to_float, %[[#A]] : !s32i), !cir.double
+// CIR-AFTER-NEXT: %{{.+}} = cir.cast int_to_float %[[#A]] : !s32i -> !cir.double
 
 //      LLVM: %[[#A:]] = extractvalue { i32, i32 } %{{.+}}, 0
 // LLVM-NEXT: %{{.+}} = sitofp i32 %[[#A]] to double
 
-//      CIR-BEFORE: %[[#A:]] = cir.cast(float_complex_to_real, %{{.+}} : !cir.complex<!cir.double>), !cir.double
-// CIR-BEFORE-NEXT: %{{.+}} = cir.cast(float_to_int, %[[#A]] : !cir.double), !s32i
+//      CIR-BEFORE: %[[#A:]] = cir.cast float_complex_to_real %{{.+}} : !cir.complex<!cir.double> -> !cir.double
+// CIR-BEFORE-NEXT: %{{.+}} = cir.cast float_to_int %[[#A]] : !cir.double -> !s32i
 
 //      CIR-AFTER: %[[#A:]] = cir.complex.real %{{.+}} : !cir.complex<!cir.double> -> !cir.double
-// CIR-AFTER-NEXT: %{{.+}} = cir.cast(float_to_int, %[[#A]] : !cir.double), !s32i
+// CIR-AFTER-NEXT: %{{.+}} = cir.cast float_to_int %[[#A]] : !cir.double -> !s32i
 
 //      LLVM: %[[#A:]] = extractvalue { double, double } %{{.+}}, 0
 // LLVM-NEXT: %{{.+}} = fptosi double %[[#A]] to i32
@@ -167,12 +167,12 @@ void complex_to_bool() {
 
 // CHECK-LABEL: @complex_to_bool()
 
-// CIR-BEFORE: %{{.+}} = cir.cast(float_complex_to_bool, %{{.+}} : !cir.complex<!cir.double>), !cir.bool
+// CIR-BEFORE: %{{.+}} = cir.cast float_complex_to_bool %{{.+}} : !cir.complex<!cir.double> -> !cir.bool
 
 //      CIR-AFTER: %[[#REAL:]] = cir.complex.real %{{.+}} : !cir.complex<!cir.double> -> !cir.double
 // CIR-AFTER-NEXT: %[[#IMAG:]] = cir.complex.imag %{{.+}} : !cir.complex<!cir.double> -> !cir.double
-// CIR-AFTER-NEXT: %[[#RB:]] = cir.cast(float_to_bool, %[[#REAL]] : !cir.double), !cir.bool
-// CIR-AFTER-NEXT: %[[#IB:]] = cir.cast(float_to_bool, %[[#IMAG]] : !cir.double), !cir.bool
+// CIR-AFTER-NEXT: %[[#RB:]] = cir.cast float_to_bool %[[#REAL]] : !cir.double -> !cir.bool
+// CIR-AFTER-NEXT: %[[#IB:]] = cir.cast float_to_bool %[[#IMAG]] : !cir.double -> !cir.bool
 // CIR-AFTER-NEXT: %[[#A:]] = cir.const #true
 // CIR-AFTER-NEXT: %{{.+}} = cir.select if %[[#RB]] then %[[#A]] else %[[#IB]] : (!cir.bool, !cir.bool, !cir.bool) -> !cir.bool
 
@@ -182,12 +182,12 @@ void complex_to_bool() {
 // LLVM-NEXT:   %[[#IB:]] = fcmp une double %[[#IMAG]], 0.000000e+00
 // LLVM-NEXT:   %{{.+}} = or i1 %[[#RB]], %[[#IB]]
 
-// CIR-BEFORE: %{{.+}} = cir.cast(int_complex_to_bool, %{{.+}} : !cir.complex<!s32i>), !cir.bool
+// CIR-BEFORE: %{{.+}} = cir.cast int_complex_to_bool %{{.+}} : !cir.complex<!s32i> -> !cir.bool
 
 //      CIR-AFTER: %[[#REAL:]] = cir.complex.real %{{.+}} : !cir.complex<!s32i> -> !s32i
 // CIR-AFTER-NEXT: %[[#IMAG:]] = cir.complex.imag %{{.+}} : !cir.complex<!s32i> -> !s32i
-// CIR-AFTER-NEXT: %[[#RB:]] = cir.cast(int_to_bool, %[[#REAL]] : !s32i), !cir.bool
-// CIR-AFTER-NEXT: %[[#IB:]] = cir.cast(int_to_bool, %[[#IMAG]] : !s32i), !cir.bool
+// CIR-AFTER-NEXT: %[[#RB:]] = cir.cast int_to_bool %[[#REAL]] : !s32i -> !cir.bool
+// CIR-AFTER-NEXT: %[[#IB:]] = cir.cast int_to_bool %[[#IMAG]] : !s32i -> !cir.bool
 // CIR-AFTER-NEXT: %[[#A:]] = cir.const #true
 // CIR-AFTER-NEXT: %{{.+}} = cir.select if %[[#RB]] then %[[#A]] else %[[#IB]] : (!cir.bool, !cir.bool, !cir.bool) -> !cir.bool
 
@@ -211,9 +211,9 @@ void lvalue_to_rvalue_bitcast() {
 
 // CHECK-LABEL: @lvalue_to_rvalue_bitcast()
 
-// CIR-BEFORE: %{{.+}} = cir.cast(bitcast, %{{.+}} : !cir.ptr<!rec_CX>), !cir.ptr<!cir.complex<!cir.double>>
+// CIR-BEFORE: %{{.+}} = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_CX> -> !cir.ptr<!cir.complex<!cir.double>>
 
-// CIR-AFTER: %{{.+}} = cir.cast(bitcast, %{{.+}} : !cir.ptr<!rec_CX>), !cir.ptr<!cir.complex<!cir.double>>
+// CIR-AFTER: %{{.+}} = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_CX> -> !cir.ptr<!cir.complex<!cir.double>>
 
 // LLVM: %[[PTR_ADDR:.*]] = alloca %struct.CX, i64 1, align 8
 // LLVM: %[[COMPLEX_ADDR:.*]] = alloca { double, double }, i64 1, align 8
@@ -228,12 +228,12 @@ void complex_to_complex_cast() {
 }
 
 // CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[FP_COMPLEX:.*]] = cir.cast(float_complex, %[[TMP]] : !cir.complex<!cir.float>), !cir.complex<!cir.double>
+// CIR-BEFORE: %[[FP_COMPLEX:.*]] = cir.cast float_complex %[[TMP]] : !cir.complex<!cir.float> -> !cir.complex<!cir.double>
 
 // CIR-AFTER: %[[#REAL:]] = cir.complex.real %{{.*}} : !cir.complex<!cir.float> -> !cir.float
 // CIR-AFTER: %[[#IMAG:]] = cir.complex.imag %{{.*}} : !cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[#REAL_FP_CAST:]] = cir.cast(floating, %[[#REAL]] : !cir.float), !cir.double
-// CIR-AFTER: %[[#IMAG_FP_CAST:]] = cir.cast(floating, %[[#IMAG]] : !cir.float), !cir.double
+// CIR-AFTER: %[[#REAL_FP_CAST:]] = cir.cast floating %[[#REAL]] : !cir.float -> !cir.double
+// CIR-AFTER: %[[#IMAG_FP_CAST:]] = cir.cast floating %[[#IMAG]] : !cir.float -> !cir.double
 // CIR-AFTER: %{{.*}} = cir.complex.create %[[#REAL_FP_CAST]], %[[#IMAG_FP_CAST]] : !cir.double -> !cir.complex<!cir.double>
 
 // LLVM: %[[#REAL:]] = extractvalue { float, float } %{{.*}}, 0
@@ -244,12 +244,12 @@ void complex_to_complex_cast() {
 // LLVM: %{{.*}} = insertvalue { double, double } %[[TMP]], double %[[#IMAG_FP_CAST]], 1
 
 // CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.complex<!s16i>>, !cir.complex<!s16i>
-// CIR-BEFORE: %[[INT_COMPLEX:.*]] = cir.cast(int_complex, %[[TMP]] : !cir.complex<!s16i>), !cir.complex<!s32i>
+// CIR-BEFORE: %[[INT_COMPLEX:.*]] = cir.cast int_complex %[[TMP]] : !cir.complex<!s16i> -> !cir.complex<!s32i>
 
 // CIR-AFTER: %[[#REAL:]] = cir.complex.real %{{.*}} : !cir.complex<!s16i> -> !s16i
 // CIR-AFTER: %[[#IMAG:]] = cir.complex.imag %{{.*}} : !cir.complex<!s16i> -> !s16i
-// CIR-AFTER: %[[#REAL_INT_CAST:]] = cir.cast(integral, %[[#REAL]] : !s16i), !s32i
-// CIR-AFTER: %[[#IMAG_INT_CAST:]] = cir.cast(integral, %[[#IMAG]] : !s16i), !s32i
+// CIR-AFTER: %[[#REAL_INT_CAST:]] = cir.cast integral %[[#REAL]] : !s16i -> !s32i
+// CIR-AFTER: %[[#IMAG_INT_CAST:]] = cir.cast integral %[[#IMAG]] : !s16i -> !s32i
 // CIR-AFTER: %{{.*}} = cir.complex.create %[[#REAL_INT_CAST]], %[[#IMAG_INT_CAST]] : !s32i -> !cir.complex<!s32i>
 
 // LLVM: %[[#REAL:]] = extractvalue { i16, i16 } %{{.*}}, 0
diff --git a/clang/test/CIR/CodeGen/complex-cast.cpp b/clang/test/CIR/CodeGen/complex-cast.cpp
index fb90f6245c9b..262d8128f994 100644
--- a/clang/test/CIR/CodeGen/complex-cast.cpp
+++ b/clang/test/CIR/CodeGen/complex-cast.cpp
@@ -13,9 +13,9 @@ void complex_lvalue_bitcast() {
   (double _Complex &)a = {};
 }
 
-// CIR-BEFORE: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>), !cir.ptr<!cir.complex<!cir.double>>
+// CIR-BEFORE: %{{.*}} = cir.cast bitcast %{{.*}} : !cir.ptr<!rec_CX> -> !cir.ptr<!cir.complex<!cir.double>>
 
-// CIR-AFTER: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>), !cir.ptr<!cir.complex<!cir.double>>
+// CIR-AFTER: %{{.*}} = cir.cast bitcast %{{.*}} : !cir.ptr<!rec_CX> -> !cir.ptr<!cir.complex<!cir.double>>
 
 // LLVM: %[[A_ADDR:.*]] = alloca %struct.CX, i64 1, align 8
 // LLVM: store { double, double } zeroinitializer, ptr %[[A_ADDR]], align 8
diff --git a/clang/test/CIR/CodeGen/compound-literal.c b/clang/test/CIR/CodeGen/compound-literal.c
index 56b7f5c07b14..aa57a0262d94 100644
--- a/clang/test/CIR/CodeGen/compound-literal.c
+++ b/clang/test/CIR/CodeGen/compound-literal.c
@@ -79,13 +79,13 @@ void split_large_page(unsigned long addr, pgprot_t prot)
 // CIR:   {{.*}} = cir.scope {
 // CIR:     %[[VAL_4:.*]] = cir.alloca !rec_pgprot_t, !cir.ptr<!rec_pgprot_t>, ["ref.tmp0"] {alignment = 8 : i64} loc(#loc64)
 // 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:     %[[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>
 // CIR:     } else {
 // CIR:       %[[VAL_7:.*]] = cir.get_member %[[VAL_4]][0] {name = "pgprot"} : !cir.ptr<!rec_pgprot_t> -> !cir.ptr<!u64i>
 // CIR:       %[[VAL_8:.*]] = cir.const #cir.int<1> : !s32i
-// CIR:       %[[VAL_9:.*]] = cir.cast(integral, %[[VAL_8]] : !s32i), !u64i
+// CIR:       %[[VAL_9:.*]] = cir.cast integral %[[VAL_8]] : !s32i -> !u64i
 // 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>
diff --git a/clang/test/CIR/CodeGen/conditional-cleanup.cpp b/clang/test/CIR/CodeGen/conditional-cleanup.cpp
index b61b6c2e555c..2fbf882acade 100644
--- a/clang/test/CIR/CodeGen/conditional-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/conditional-cleanup.cpp
@@ -42,7 +42,7 @@ namespace test7 {
 // CIR:     %[[TRUE1:.*]] = cir.const #true
 
 // CIR:     %[[NULL_CHECK0:.*]] = cir.cmp(ne
-// CIR:     %[[PTR_B0:.*]] = cir.cast(bitcast
+// CIR:     %[[PTR_B0:.*]] = cir.cast bitcast
 // CIR:     cir.store align(1) %[[FALSE1]], %[[CLEANUP_COND_OUTER]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR:     cir.store align(1) %[[FALSE0]], %[[CLEANUP_COND_INNER]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR:     cir.if %[[NULL_CHECK0]] {
@@ -52,7 +52,7 @@ namespace test7 {
 // CIR:       cir.store{{.*}} %[[TRUE1]], %[[CLEANUP_COND_OUTER]] : !cir.bool, !cir.ptr<!cir.bool>
 
 // CIR:       %[[NULL_CHECK1:.*]] = cir.cmp(ne
-// CIR:       %[[PTR_B1:.*]] = cir.cast(bitcast
+// CIR:       %[[PTR_B1:.*]] = cir.cast bitcast
 // CIR:       cir.if %[[NULL_CHECK1]] {
 
 // Ctor call: @test7::A::A()
@@ -106,7 +106,7 @@ namespace test7 {
 // CIR_EH:             %[[VAL_16:.*]] = cir.call @_ZN5test71BnwEm(%[[VAL_15]]) : (!u64i) -> !cir.ptr<!void>
 // CIR_EH:             %[[VAL_17:.*]] = cir.const #{{.*}}<null> : !cir.ptr<!void>
 // CIR_EH:             %[[VAL_18:.*]] = cir.cmp(ne, %[[VAL_16]], %[[VAL_17]]) : !cir.ptr<!void>, !cir.bool
-// CIR_EH:             %[[VAL_19:.*]] = cir.cast(bitcast, %[[VAL_16]] : !cir.ptr<!void>), !cir.ptr<!rec_test73A3AB>
+// CIR_EH:             %[[VAL_19:.*]] = cir.cast bitcast %[[VAL_16]] : !cir.ptr<!void> -> !cir.ptr<!rec_test73A3AB>
 // CIR_EH:             cir.store align(1) %[[VAL_13]], %[[VAL_1]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR_EH:             cir.store align(1) %[[VAL_11]], %[[VAL_3]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR_EH:             cir.store align(1) %[[VAL_9]], %[[VAL_4]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -130,7 +130,7 @@ namespace test7 {
 // CIR_EH:               %[[VAL_22:.*]] = cir.call @_ZN5test71BnwEm(%[[VAL_21]]) : (!u64i) -> !cir.ptr<!void>
 // CIR_EH:               %[[VAL_23:.*]] = cir.const #{{.*}}<null> : !cir.ptr<!void>
 // CIR_EH:               %[[VAL_24:.*]] = cir.cmp(ne, %[[VAL_22]], %[[VAL_23]]) : !cir.ptr<!void>, !cir.bool
-// CIR_EH:               %[[VAL_25:.*]] = cir.cast(bitcast, %[[VAL_22]] : !cir.ptr<!void>), !cir.ptr<!rec_test73A3AB>
+// CIR_EH:               %[[VAL_25:.*]] = cir.cast bitcast %[[VAL_22]] : !cir.ptr<!void> -> !cir.ptr<!rec_test73A3AB>
 // CIR_EH:               cir.if %[[VAL_24]] {
 // CIR_EH:                 cir.store{{.*}} %[[VAL_10]], %[[VAL_4]] : !cir.bool, !cir.ptr<!cir.bool>
 // CIR_EH:                 cir.try synthetic cleanup {
diff --git a/clang/test/CIR/CodeGen/const-bitfields.c b/clang/test/CIR/CodeGen/const-bitfields.c
index 558b4581ff48..f0576b85d69f 100644
--- a/clang/test/CIR/CodeGen/const-bitfields.c
+++ b/clang/test/CIR/CodeGen/const-bitfields.c
@@ -29,7 +29,7 @@ struct Inner var = { 1, 0, 1, 21};
 
 // CHECK: cir.func {{.*@getZ()}}
 // CHECK:   %1 = cir.get_global @GV : !cir.ptr<!rec_anon_struct>
-// CHECK:   %2 = cir.cast(bitcast, %1 : !cir.ptr<!rec_anon_struct>), !cir.ptr<!rec_T>
+// CHECK:   %2 = cir.cast bitcast %1 : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!rec_T>
 // CHECK:   %3 = cir.get_member %2[0] {name = "Z"} : !cir.ptr<!rec_T> -> !cir.ptr<!u32i>
 // CHECK:   %4 = cir.get_bitfield align(4) (#bfi_Z, %3 : !cir.ptr<!u32i>) -> !s32i
 int getZ() {
@@ -39,7 +39,7 @@ int getZ() {
 // check the type used is the type of T struct for plain field
 // CHECK:  cir.func {{.*@getW()}}
 // CHECK:    %1 = cir.get_global @GV : !cir.ptr<!rec_anon_struct>
-// CHECK:    %2 = cir.cast(bitcast, %1 : !cir.ptr<!rec_anon_struct>), !cir.ptr<!rec_T>
+// CHECK:    %2 = cir.cast bitcast %1 : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!rec_T>
 // CHECK:    %3 = cir.get_member %2[1] {name = "W"} : !cir.ptr<!rec_T> -> !cir.ptr<!s32i>
 int getW() {
   return GV.W;
diff --git a/clang/test/CIR/CodeGen/copy-constructor.cpp b/clang/test/CIR/CodeGen/copy-constructor.cpp
index f11740d52caf..1e012832d9c3 100644
--- a/clang/test/CIR/CodeGen/copy-constructor.cpp
+++ b/clang/test/CIR/CodeGen/copy-constructor.cpp
@@ -52,8 +52,8 @@ struct ManyMembers {
 // 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:    %[[#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]]
@@ -63,8 +63,8 @@ struct ManyMembers {
 // 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:    %[[#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]]
@@ -74,8 +74,8 @@ struct ManyMembers {
 // 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>
-// CIR-NEXT:    %[[#OTHER_O_CAST:]] = cir.cast(bitcast, %[[#OTHER_O]] : !cir.ptr<!cir.ptr<!s32i>>), !cir.ptr<!void>
+// CIR-NEXT:    %[[#THIS_O_CAST:]] = cir.cast bitcast %[[#THIS_O]] : !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!void>
+// CIR-NEXT:    %[[#OTHER_O_CAST:]] = cir.cast bitcast %[[#OTHER_O]] : !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!void>
 // CIR-NEXT:    cir.libc.memcpy %[[#MEMCPY_SIZE]] bytes from %[[#OTHER_O_CAST]] to %[[#THIS_O_CAST]]
 // CIR-NEXT:    cir.return
 // CIR-NEXT:  }
diff --git a/clang/test/CIR/CodeGen/ctor-alias.cpp b/clang/test/CIR/CodeGen/ctor-alias.cpp
index 5c27762bdfe3..154f37da7a16 100644
--- a/clang/test/CIR/CodeGen/ctor-alias.cpp
+++ b/clang/test/CIR/CodeGen/ctor-alias.cpp
@@ -21,7 +21,7 @@ void t() {
 //      CHECK:   cir.func dso_local @_Z1tv
 // CHECK-NEXT:     %0 = cir.alloca !rec_DummyString, !cir.ptr<!rec_DummyString>, ["s4", init] {alignment = 1 : i64}
 // CHECK-NEXT:     %1 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 5>>
-// CHECK-NEXT:     %2 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s8i x 5>>), !cir.ptr<!s8i>
+// CHECK-NEXT:     %2 = cir.cast array_to_ptrdecay %1 : !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!s8i>
 // CHECK-NEXT:     cir.call @_ZN11DummyStringC2EPKc(%0, %2) : (!cir.ptr<!rec_DummyString>, !cir.ptr<!s8i>) -> ()
 // CHECK-NEXT:     cir.return
 
diff --git a/clang/test/CIR/CodeGen/dtors-scopes.cpp b/clang/test/CIR/CodeGen/dtors-scopes.cpp
index 229fa9f9274b..9ce961f7262e 100644
--- a/clang/test/CIR/CodeGen/dtors-scopes.cpp
+++ b/clang/test/CIR/CodeGen/dtors-scopes.cpp
@@ -25,7 +25,7 @@ void dtor1() {
 // DTOR_BODY: cir.func linkonce_odr @_ZN1CD2Ev{{.*}}{
 // DTOR_BODY:   %2 = cir.get_global @printf
 // DTOR_BODY:   %3 = cir.get_global @".str.2"
-// DTOR_BODY:   %4 = cir.cast(array_to_ptrdecay, %3
+// DTOR_BODY:   %4 = cir.cast array_to_ptrdecay %3
 // DTOR_BODY:   %5 = cir.call @printf(%4)
 // DTOR_BODY:   cir.return
 
diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp
index ffc68a8e79a8..be738961378d 100644
--- a/clang/test/CIR/CodeGen/dtors.cpp
+++ b/clang/test/CIR/CodeGen/dtors.cpp
@@ -45,7 +45,7 @@ class B : public A
 // CHECK:   %0 = cir.alloca !rec_PSEvent, !cir.ptr<!rec_PSEvent>, ["p", init] {alignment = 8 : i64}
 // CHECK:   %1 = cir.const #cir.int<1> : !s32i
 // CHECK:   %2 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 5>>
-// CHECK:   %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!s8i x 5>>), !cir.ptr<!s8i>
+// CHECK:   %3 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!s8i>
 // CHECK:   cir.call @_ZN7PSEventC1E6EFModePKc(%0, %1, %3) : (!cir.ptr<!rec_PSEvent>, !s32i, !cir.ptr<!s8i>) -> ()
 // CHECK:   cir.return
 // CHECK: }
@@ -138,7 +138,7 @@ void pseudo_dtor() {
 // 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:     cir.call @_ZN1BD2Ev(%1) : (!cir.ptr<![[ClassB]]>) -> ()
-// CHECK:     %2 = cir.cast(bitcast, %1 : !cir.ptr<![[ClassB]]>), !cir.ptr<!void>
+// CHECK:     %2 = cir.cast bitcast %1 : !cir.ptr<![[ClassB]]> -> !cir.ptr<!void>
 // CHECK:     cir.call @_ZdlPvm(%2, %3) : (!cir.ptr<!void>, !u64i) -> ()
 // CHECK:     cir.return
 // CHECK:   }
diff --git a/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp b/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
index 6d8dc86c932f..91ff84a0d531 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast-exact.cpp
@@ -17,11 +17,11 @@ 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-NEXT: %[[#EXPECTED_VPTR:]] = cir.vtable.address_point(@_ZTV7Derived, address_point = <index = 0, offset = 2>) : !cir.vptr
-  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!cir.vptr>
+  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base1> -> !cir.ptr<!cir.vptr>
   // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load{{.*}} %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.vptr>, !cir.vptr
   // CHECK-NEXT: %[[#SUCCESS:]] = cir.cmp(eq, %[[#SRC_VPTR]], %[[#EXPECTED_VPTR]]) : !cir.vptr, !cir.bool
   // CHECK-NEXT: %{{.+}} = cir.ternary(%[[#SUCCESS]], true {
-  // CHECK-NEXT:   %[[#RES:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!rec_Derived>
+  // CHECK-NEXT:   %[[#RES:]] = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base1> -> !cir.ptr<!rec_Derived>
   // CHECK-NEXT:   cir.yield %[[#RES]] : !cir.ptr<!rec_Derived>
   // CHECK-NEXT: }, false {
   // CHECK-NEXT:   %[[#NULL:]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_Derived>
@@ -40,7 +40,7 @@ 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-NEXT: %[[#EXPECTED_VPTR:]] = cir.vtable.address_point(@_ZTV7Derived, address_point = <index = 0, offset = 2>) : !cir.vptr
-  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!cir.vptr>
+  // CHECK-NEXT: %[[#SRC_VPTR_PTR:]] = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base1> -> !cir.ptr<!cir.vptr>
   // CHECK-NEXT: %[[#SRC_VPTR:]] = cir.load{{.*}} %[[#SRC_VPTR_PTR]] : !cir.ptr<!cir.vptr>, !cir.vptr
   // CHECK-NEXT: %[[#SUCCESS:]] = cir.cmp(eq, %[[#SRC_VPTR]], %[[#EXPECTED_VPTR]]) : !cir.vptr, !cir.bool
   // CHECK-NEXT: %[[#FAILED:]] = cir.unary(not, %[[#SUCCESS]]) : !cir.bool, !cir.bool
@@ -48,7 +48,7 @@ Derived &ref_cast(Base1 &ref) {
   // CHECK-NEXT:   cir.call @__cxa_bad_cast() : () -> ()
   // CHECK-NEXT:   cir.unreachable
   // CHECK-NEXT: }
-  // CHECK-NEXT: %{{.+}} = cir.cast(bitcast, %[[#SRC]] : !cir.ptr<!rec_Base1>), !cir.ptr<!rec_Derived>
+  // CHECK-NEXT: %{{.+}} = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base1> -> !cir.ptr<!rec_Derived>
 }
 
 //      LLVM: define dso_local noundef ptr @_Z8ref_castR5Base1(ptr readonly returned captures(ret: address, provenance) %[[#SRC:]])
diff --git a/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp b/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
index fe8282af63a6..20498f905f8d 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast-relative-layout.cpp
@@ -17,17 +17,17 @@ void *ptr_cast_to_complete(Base *ptr) {
 
 //      AFTER: cir.func dso_local @_Z20ptr_cast_to_completeP4Base
 //      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:   %[[#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.vtable.get_vptr %[[#SRC:]] : !cir.ptr<!rec_Base> -> !cir.ptr<!cir.vptr>
 // AFTER-NEXT:     %[[#VPTR:]] = cir.load %[[#VPTR_PTR]] : !cir.ptr<!cir.vptr>, !cir.vptr
-// AFTER-NEXT:     %[[#ELEM_PTR:]] = cir.cast(bitcast, %[[#VPTR:]] : !cir.vptr), !cir.ptr<!s32i>
+// AFTER-NEXT:     %[[#ELEM_PTR:]] = cir.cast bitcast %[[#VPTR:]] : !cir.vptr -> !cir.ptr<!s32i>
 // AFTER-NEXT:     %[[#MINUS_TWO:]] = cir.const #cir.int<-2> : !s64i
 // AFTER-NEXT:     %[[#OFFSET_TO_TOP_PTR:]] = cir.ptr_stride %[[#ELEM_PTR]], %[[#MINUS_TWO:]] : (!cir.ptr<!s32i>, !s64i) -> !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>
+// AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base> -> !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DST_BYTES_PTR:]] = cir.ptr_stride %[[#SRC_BYTES_PTR]], %[[#OFFSET_TO_TOP]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
-// AFTER-NEXT:     %[[#DST:]] = cir.cast(bitcast, %[[#DST_BYTES_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!void>
+// AFTER-NEXT:     %[[#DST:]] = cir.cast bitcast %[[#DST_BYTES_PTR]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
 // AFTER-NEXT:     cir.yield %[[#DST]] : !cir.ptr<!void>
 // AFTER-NEXT:   }, false {
 // AFTER-NEXT:     %[[#NULL:]] = cir.const #cir.ptr<null> : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/dynamic-cast.cpp b/clang/test/CIR/CodeGen/dynamic-cast.cpp
index 56b42c30d40b..37791de09a3d 100644
--- a/clang/test/CIR/CodeGen/dynamic-cast.cpp
+++ b/clang/test/CIR/CodeGen/dynamic-cast.cpp
@@ -23,14 +23,14 @@ Derived *ptr_cast(Base *b) {
 
 //      AFTER: cir.func dso_local @_Z8ptr_castP4Base
 //      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:   %[[#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>
+// AFTER-NEXT:     %[[#SRC_VOID_PTR:]] = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base> -> !cir.ptr<!void>
 // AFTER-NEXT:     %[[#BASE_RTTI:]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DERIVED_RTTI:]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#HINT:]] = cir.const #cir.int<0> : !s64i
 // AFTER-NEXT:     %[[#RT_CALL_RET:]] = cir.call @__dynamic_cast(%[[#SRC_VOID_PTR]], %[[#BASE_RTTI]], %[[#DERIVED_RTTI]], %[[#HINT]]) : (!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void>
-// AFTER-NEXT:     %[[#CASTED:]] = cir.cast(bitcast, %[[#RT_CALL_RET]] : !cir.ptr<!void>), !cir.ptr<!rec_Derived>
+// AFTER-NEXT:     %[[#CASTED:]] = cir.cast bitcast %[[#RT_CALL_RET]] : !cir.ptr<!void> -> !cir.ptr<!rec_Derived>
 // AFTER-NEXT:     cir.yield %[[#CASTED]] : !cir.ptr<!rec_Derived>
 // AFTER-NEXT:   }, false {
 // AFTER-NEXT:     %[[#NULL_PTR:]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_Derived>
@@ -47,18 +47,18 @@ Derived &ref_cast(Base &b) {
 // BEFORE: }
 
 //      AFTER: cir.func dso_local @_Z8ref_castR4Base
-//      AFTER:   %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr<!rec_Base>), !cir.ptr<!void>
+//      AFTER:   %[[#SRC_VOID_PTR:]] = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_Base> -> !cir.ptr<!void>
 // AFTER-NEXT:   %[[#SRC_RTTI:]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i>
 // AFTER-NEXT:   %[[#DEST_RTTI:]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i>
 // AFTER-NEXT:   %[[#OFFSET_HINT:]] = cir.const #cir.int<0> : !s64i
 // AFTER-NEXT:   %[[#CASTED_PTR:]] = cir.call @__dynamic_cast(%[[#SRC_VOID_PTR]], %[[#SRC_RTTI]], %[[#DEST_RTTI]], %[[#OFFSET_HINT]]) : (!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void>
-// AFTER-NEXT:   %[[#CASTED_PTR_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#CASTED_PTR]] : !cir.ptr<!void>), !cir.bool
+// AFTER-NEXT:   %[[#CASTED_PTR_IS_NOT_NULL:]] = cir.cast ptr_to_bool %[[#CASTED_PTR]] : !cir.ptr<!void> -> !cir.bool
 // AFTER-NEXT:   %[[#CASTED_PTR_IS_NULL:]] = cir.unary(not, %[[#CASTED_PTR_IS_NOT_NULL]]) : !cir.bool, !cir.bool
 // AFTER-NEXT:   cir.if %[[#CASTED_PTR_IS_NULL]] {
 // AFTER-NEXT:     cir.call @__cxa_bad_cast() : () -> ()
 // AFTER-NEXT:     cir.unreachable
 // AFTER-NEXT:   }
-// AFTER-NEXT:   %{{.+}} = cir.cast(bitcast, %[[#CASTED_PTR]] : !cir.ptr<!void>), !cir.ptr<!rec_Derived>
+// AFTER-NEXT:   %{{.+}} = cir.cast bitcast %[[#CASTED_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_Derived>
 //      AFTER: }
 
 void *ptr_cast_to_complete(Base *ptr) {
@@ -71,17 +71,17 @@ void *ptr_cast_to_complete(Base *ptr) {
 
 //      AFTER: cir.func dso_local @_Z20ptr_cast_to_completeP4Base
 //      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:   %[[#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.vtable.get_vptr %[[#SRC]] : !cir.ptr<!rec_Base> -> !cir.ptr<!cir.vptr>
 // AFTER-NEXT:     %[[#VPTR:]] = cir.load %[[#VPTR_PTR]] : !cir.ptr<!cir.vptr>, !cir.vptr
-// AFTER-NEXT:     %[[#ELEM_PTR:]] = cir.cast(bitcast, %[[#VPTR]] : !cir.vptr), !cir.ptr<!s64i>
+// AFTER-NEXT:     %[[#ELEM_PTR:]] = cir.cast bitcast %[[#VPTR]] : !cir.vptr -> !cir.ptr<!s64i>
 // AFTER-NEXT:     %[[#MINUS_TWO:]] = cir.const #cir.int<-2> : !s64i
 // AFTER-NEXT:     %[[#BASE_OFFSET_PTR:]] = cir.ptr_stride %[[#ELEM_PTR]], %[[#MINUS_TWO:]] : (!cir.ptr<!s64i>, !s64i) -> !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>
+// AFTER-NEXT:     %[[#SRC_BYTES_PTR:]] = cir.cast bitcast %[[#SRC]] : !cir.ptr<!rec_Base> -> !cir.ptr<!u8i>
 // AFTER-NEXT:     %[[#DST_BYTES_PTR:]] = cir.ptr_stride %[[#SRC_BYTES_PTR]], %[[#BASE_OFFSET]] : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
-// AFTER-NEXT:     %[[#CASTED_PTR:]] = cir.cast(bitcast, %[[#DST_BYTES_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!void>
+// AFTER-NEXT:     %[[#CASTED_PTR:]] = cir.cast bitcast %[[#DST_BYTES_PTR]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
 // AFTER-NEXT:     cir.yield %[[#CASTED_PTR]] : !cir.ptr<!void>
 // AFTER-NEXT:   }, false {
 // AFTER-NEXT:     %[[#NULL_PTR:]] = cir.const #cir.ptr<null> : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/evaluate-expr.c b/clang/test/CIR/CodeGen/evaluate-expr.c
index d896fbe7d84b..deb8fac16bd5 100644
--- a/clang/test/CIR/CodeGen/evaluate-expr.c
+++ b/clang/test/CIR/CodeGen/evaluate-expr.c
@@ -11,7 +11,7 @@ void foo() {
 // CHECK:  cir.func no_proto dso_local @foo()
 // CHECK:    cir.scope {
 // CHECK:      [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
-// CHECK:      [[FALSE:%.*]] = cir.cast(int_to_bool, [[ZERO:%.*]] : !s32i), !cir.bool
+// CHECK:      [[FALSE:%.*]] = cir.cast int_to_bool [[ZERO:%.*]] : !s32i -> !cir.bool
 // CHECK:      cir.if [[FALSE]] {
 // CHECK:        cir.return
 // CHECK:      }
diff --git a/clang/test/CIR/CodeGen/finegrain-bitfield-access.cpp b/clang/test/CIR/CodeGen/finegrain-bitfield-access.cpp
index f87740fae0c9..72371242e1a8 100644
--- a/clang/test/CIR/CodeGen/finegrain-bitfield-access.cpp
+++ b/clang/test/CIR/CodeGen/finegrain-bitfield-access.cpp
@@ -70,7 +70,7 @@ void write8_1() {
 
 // CIR-LABEL: @_Z8write8_1v
 // CIR: [[CONST3:%.*]] = cir.const #cir.int<3> : !s32i
-// CIR: [[INT3:%.*]] = cir.cast(integral, [[CONST3]] : !s32i), !u32i
+// CIR: [[INT3:%.*]] = cir.cast integral [[CONST3]] : !s32i -> !u32i
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[1] {name = "f3"} : !cir.ptr<!rec_S1> -> !cir.ptr<!u8i>
 // CIR: cir.set_bitfield align(1) (#bfi_f3, [[MEMBER]] : !cir.ptr<!u8i>, [[INT3]] : !u32i) -> !u32i
 
@@ -116,7 +116,7 @@ void write8_2() {
 
 // CIR-LABEL: @_Z8write8_2v
 // CIR: [[CONST3:%.*]] = cir.const #cir.int<3> : !s32i
-// CIR: [[INT3:%.*]] = cir.cast(integral, [[CONST3]] : !s32i), !u32i
+// CIR: [[INT3:%.*]] = cir.cast integral [[CONST3]] : !s32i -> !u32i
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[2] {name = "f5"} : !cir.ptr<!rec_S1> -> !cir.ptr<!u16i>
 // CIR: cir.set_bitfield align(2) (#bfi_f5, %3 : !cir.ptr<!u16i>, {{.*}} : !u32i) -> !u32i
 
@@ -141,7 +141,7 @@ unsigned read16_1() {
 // CIR-LABEL: @_Z8read16_1v
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[0] {name = "f1"} : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: [[BITFI:%.*]] = cir.get_bitfield align(8) (#bfi_f1, [[MEMBER]] : !cir.ptr<!u16i>) -> !u64i
-// CIR: [[BFCAST:%.*]] = cir.cast(integral, [[BITFI]] : !u64i), !u32i
+// CIR: [[BFCAST:%.*]] = cir.cast integral [[BITFI]] : !u64i -> !u32i
 // CIR: cir.store [[BFCAST]], {{.*}} : !u32i, !cir.ptr<!u32i>
 // CIR: [[RET:%.*]] = cir.load {{.*}} : !cir.ptr<!u32i>, !u32i
 // CIR: cir.return [[RET]] : !u32i
@@ -167,7 +167,7 @@ unsigned read16_2() {
 // CIR-LABEL: @_Z8read16_2v
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[1] {name = "f2"} : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: [[BITFI:%.*]] = cir.get_bitfield align(2) (#bfi_f2, [[MEMBER]] : !cir.ptr<!u16i>) -> !u64i
-// CIR: [[BFCAST:%.*]] = cir.cast(integral, [[BITFI]] : !u64i), !u32i
+// CIR: [[BFCAST:%.*]] = cir.cast integral [[BITFI]] : !u64i -> !u32i
 // CIR: cir.store [[BFCAST]], {{.*}} : !u32i, !cir.ptr<!u32i>
 // CIR: [[RET:%.*]] = cir.load {{.*}} : !cir.ptr<!u32i>, !u32i
 // CIR: cir.return [[RET]] : !u32i
@@ -192,7 +192,7 @@ void write16_1() {
 
 // CIR-LABEL: @_Z9write16_1v
 // CIR: [[CONST5:%.*]] = cir.const #cir.int<5> : !s32i
-// CIR: [[INT5:%.*]] = cir.cast(integral, [[CONST5]] : !s32i), !u64i
+// CIR: [[INT5:%.*]] = cir.cast integral [[CONST5]] : !s32i -> !u64i
 // CIR: [[MEMBER:%.*]]  = cir.get_member {{.*}}[0] {name = "f1"} : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: cir.set_bitfield align(8) (#bfi_f1, [[MEMBER]] : !cir.ptr<!u16i>, [[INT5]] : !u64i) -> !u64i
 // CIR: cir.return
@@ -212,7 +212,7 @@ void write16_2() {
 
 // CIR-LABEL: @_Z9write16_2v
 // CIR: [[CONST5:%.*]] = cir.const #cir.int<5> : !s32i
-// CIR: [[INT5:%.*]] = cir.cast(integral, [[CONST5]] : !s32i), !u64i
+// CIR: [[INT5:%.*]] = cir.cast integral [[CONST5]] : !s32i -> !u64i
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[1] {name = "f2"} : !cir.ptr<!rec_S2> -> !cir.ptr<!u16i>
 // CIR: cir.set_bitfield align(2) (#bfi_f2, [[MEMBER]] : !cir.ptr<!u16i>, {{.*}} : !u64i) -> !u64i
 // CIR: cir.return
@@ -232,7 +232,7 @@ unsigned read32_1() {
 // CIR-LABEL: @_Z8read32_1v
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[1] {name = "f3"} : !cir.ptr<!rec_S3> -> !cir.ptr<!u32i>
 // CIR: [[BITFI:%.*]] = cir.get_bitfield align(4) (#bfi_f3_1, [[MEMBER]] : !cir.ptr<!u32i>) -> !u64i
-// CIR: [[BFCAST:%.*]] = cir.cast(integral, [[BITFI]] : !u64i), !u32i
+// CIR: [[BFCAST:%.*]] = cir.cast integral [[BITFI]] : !u64i -> !u32i
 // CIR: cir.store [[BFCAST]], {{.*}} : !u32i, !cir.ptr<!u32i>
 // CIR: [[RET:%.*]] = cir.load {{.*}} : !cir.ptr<!u32i>, !u32i
 // CIR: cir.return [[RET]] : !u32i
@@ -257,7 +257,7 @@ void write32_1() {
 
 // CIR-LABEL: @_Z9write32_1v
 // CIR: [[CONST5:%.*]] = cir.const #cir.int<5> : !s32i
-// CIR: [[INT5:%.*]] = cir.cast(integral, [[CONST5]] : !s32i), !u64i
+// CIR: [[INT5:%.*]] = cir.cast integral [[CONST5]] : !s32i -> !u64i
 // CIR: [[MEMBER:%.*]] = cir.get_member {{.*}}[1] {name = "f3"} : !cir.ptr<!rec_S3> -> !cir.ptr<!u32i>
 // CIR: cir.set_bitfield align(4) (#bfi_f3_1, [[MEMBER]] : !cir.ptr<!u32i>, [[INT5]] : !u64i) -> !u64i
 // CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/float16-ops.c b/clang/test/CIR/CodeGen/float16-ops.c
index 43f686a8b360..5f5ee53df916 100644
--- a/clang/test/CIR/CodeGen/float16-ops.c
+++ b/clang/test/CIR/CodeGen/float16-ops.c
@@ -16,29 +16,29 @@ short s0;
 
 void foo(void) {
   test = (h0);
-  // NONATIVE: %{{.+}} = cir.cast(float_to_int, %{{.+}} : !cir.f16), !u32i
-  // NATIVE: %{{.+}} = cir.cast(float_to_int, %{{.+}} : !cir.f16), !u32i
+  // NONATIVE: %{{.+}} = cir.cast float_to_int %{{.+}} : !cir.f16 -> !u32i
+  // NATIVE: %{{.+}} = cir.cast float_to_int %{{.+}} : !cir.f16 -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fptoui half %{{.+}} to i32
   // NATIVE-LLVM: %{{.+}} = fptoui half %{{.+}} to i32
 
   h0 = (test);
-  // NONATIVE: %{{.+}} = cir.cast(int_to_float, %{{.+}} : !u32i), !cir.f16
-  // NATIVE: %{{.+}} = cir.cast(int_to_float, %{{.+}} : !u32i), !cir.f16
+  // NONATIVE: %{{.+}} = cir.cast int_to_float %{{.+}} : !u32i -> !cir.f16
+  // NATIVE: %{{.+}} = cir.cast int_to_float %{{.+}} : !u32i -> !cir.f16
 
   // NONATIVE-LLVM: %{{.+}} = uitofp i32 %{{.+}} to half
   // NATIVE-LLVM: %{{.+}} = uitofp i32 %{{.+}} to half
 
   test = (!h1);
-  //      NONATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.f16), !cir.bool
+  //      NONATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.f16 -> !cir.bool
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(not, %[[#A]]) : !cir.bool, !cir.bool
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.f16), !cir.bool
+  //      NATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.f16 -> !cir.bool
   // NATIVE-NEXT: %[[#B:]] = cir.unary(not, %[[#A]]) : !cir.bool, !cir.bool
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#A:]] = fcmp une half %{{.+}}, 0xH0000
   // NONATIVE-LLVM-NEXT: %[[#B:]] = zext i1 %[[#A]] to i8
@@ -51,12 +51,12 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = zext i8 %[[#C]] to i32
 
   h1 = -h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.float), !cir.f16
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.float -> !cir.f16
   //      NATIVE: %{{.+}} = cir.unary(minus, %{{.+}}) : !cir.f16, !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
@@ -66,12 +66,12 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fneg half %{{.+}}
 
   h1 = +h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(plus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //  NATIVE-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.float), !cir.f16
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //  NATIVE-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.float -> !cir.f16
   //      NATIVE: %{{.+}} = cir.unary(plus, %{{.+}}) : !cir.f16, !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
@@ -125,10 +125,10 @@ void foo(void) {
   // NATIVE-LLVM: %{.+} = fadd half %{.+}, 0xHBC00
 
   h1 = h0 * h2;
-  //      NONATIVE: %[[#LHS:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#RHS:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#LHS:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#RHS:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#A:]] = cir.binop(mul, %[[#LHS]], %[[#RHS]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#A]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#A]] : !cir.float -> !cir.f16
 
   // NATIVE: %{{.+}} = cir.binop(mul, %{{.+}}, %{{.+}}) : !cir.f16
 
@@ -140,17 +140,17 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul half %{{.+}}, %{{.+}}
 
   h1 = h0 * (_Float16) -2.0f;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.unary(minus, %[[#B]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.f16), !cir.float
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(mul, %[[#A]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.f16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: %{{.+}} = cir.binop(mul, %{{.+}}, %[[#C]]) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
@@ -160,13 +160,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul half %{{.+}}, 0xHC000
 
   h1 = h0 * f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      NONATIVE-LLVM: %[[#RES:]] = fmul float %[[#LHS]], %{{.+}}
@@ -177,13 +177,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = f0 * h2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fmul float %{{.+}}, %[[#RHS]]
@@ -194,13 +194,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = h0 * i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(mul, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %{{.+}} = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -213,10 +213,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fmul half %{{.+}}, %[[#A]]
 
   h1 = (h0 / h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(div, %[[#A]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
 
   // NATIVE: %{{.+}} = cir.binop(div, %{{.+}}, %{{.+}}) : !cir.f16
 
@@ -228,17 +228,17 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fdiv half %{{.+}}, %{{.+}}
 
   h1 = (h0 / (_Float16) -2.0f);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.unary(minus, %[[#B]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.f16), !cir.float
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(div, %[[#A]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.f16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: %{{.+}} = cir.binop(div, %{{.+}}, %[[#C]]) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
@@ -248,13 +248,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fdiv half %{{.+}}, 0xHC000
 
   h1 = (h0 / f2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      NONATIVE-LLVM: %[[#RES:]] = fdiv float %[[#LHS]], %{{.+}}
@@ -265,13 +265,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (f0 / h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fdiv float %{{.+}}, %[[#RHS]]
@@ -282,13 +282,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (h0 / i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(div, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %{{.+}} = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -301,10 +301,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fdiv half %{{.+}}, %[[#A]]
 
   h1 = (h2 + h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(add, %[[#A]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
 
   // NATIVE: %{{.+}} = cir.binop(add, %{{.+}}, %{{.+}}) : !cir.f16
 
@@ -318,15 +318,15 @@ void foo(void) {
   h1 = ((_Float16)-2.0 + h0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#E:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#E:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(add, %[[#D]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.f16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   //      NATIVE: %{{.+}} = cir.binop(add, %[[#C]], %{{.+}}) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
@@ -336,13 +336,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd half 0xHC000, %{{.+}}
 
   h1 = (h2 + f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      NONATIVE-LLVM: %[[#RES:]] = fadd float %[[#LHS]], %{{.+}}
@@ -353,13 +353,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (f2 + h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#B:]] = fadd float %{{.+}}, %[[#A]]
@@ -370,13 +370,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (h0 + i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(add, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %{{.+}} = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -389,10 +389,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fadd half %{{.+}}, %[[#A]]
 
   h1 = (h2 - h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(sub, %[[#A]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
 
   // NATIVE: %{{.+}} = cir.binop(sub, %{{.+}}, %{{.+}}) : !cir.f16
 
@@ -406,15 +406,15 @@ void foo(void) {
   h1 = ((_Float16)-2.0f - h0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#E:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#E:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#F:]] = cir.binop(sub, %[[#D]], %[[#E]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#F]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#F]] : !cir.float -> !cir.f16
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   //      NATIVE: %{{.+}} = cir.binop(sub, %[[#C]], %{{.+}}) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
@@ -424,13 +424,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub half 0xHC000, %{{.+}}
 
   h1 = (h2 - f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      NONATIVE-LLVM: %[[#RES:]] = fsub float %[[#LHS]], %{{.+}}
@@ -441,13 +441,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (f2 - h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.float
-  // NATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %[[#RES:]] = fsub float %{{.+}}, %[[#RHS]]
@@ -458,13 +458,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (h0 - i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(sub, %[[#A]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %{{.+}} = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %{{.+}} = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -478,10 +478,10 @@ void foo(void) {
 
   test = (h2 < h0);
   //      NONATIVE: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp olt half %{{.+}}, %{{.+}}
 
@@ -489,27 +489,27 @@ void foo(void) {
 
   test = (h2 < (_Float16)42.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NONATIVE-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp olt half %{{.+}}, 0xH5140
 
   // NATIVE-LLVM: %{{.+}} = fcmp olt half %{{.+}}, 0xH5140
 
   test = (h2 < f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp olt float %[[#A]], %{{.+}}
@@ -518,13 +518,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp olt float %[[#A]], %{{.+}}
 
   test = (f2 < h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.=}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp olt float %{{.+}}, %[[#A]]
@@ -533,13 +533,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp olt float %{{.+}}, %[[#A]]
 
   test = (i0 < h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM: %{{.+}} = fcmp olt half %[[#A]], %{{.+}}
@@ -548,13 +548,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp olt half %[[#A]], %{{.+}}
 
   test = (h0 < i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp olt half %{{.+}}, %[[#A]]
@@ -564,10 +564,10 @@ void foo(void) {
 
   test = (h0 > h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt half %{{.+}}, %{{.+}}
 
@@ -575,27 +575,27 @@ void foo(void) {
 
   test = ((_Float16)42.0 > h2);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      NONATIVE: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      NATIVE: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt half 0xH5140, %{{.+}}
 
   // NATIVE-LLVM: %{{.+}} = fcmp ogt half 0xH5140, %{{.+}}
 
   test = (h0 > f2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.=}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt float %[[#LHS]], %{{.+}}
@@ -604,13 +604,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ogt float %[[#LHS]], %{{.+}}
 
   test = (f0 > h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ogt float %{{.+}}, %[[#RHS]]
@@ -619,13 +619,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp ogt float %{{.+}}, %[[#RHS]]
 
   test = (i0 > h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM: %{{.+}} = fcmp ogt half %[[#LHS]], %{{.+}}
@@ -634,13 +634,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ogt half %[[#LHS]], %{{.+}}
 
   test = (h0 > i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ogt half %{{.+}}, %[[#RHS]]
@@ -650,10 +650,10 @@ void foo(void) {
 
   test = (h2 <= h0);
   //      NONATIVE: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ole half %{{.+}}, %{{.+}}
 
@@ -661,27 +661,27 @@ void foo(void) {
 
   test = (h2 <= (_Float16)42.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NONATIVE-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp ole half %{{.+}}, 0xH5140
 
   // NATIVE-LLVM: %{{.+}} = fcmp ole half %{{.+}}, 0xH5140
 
   test = (h2 <= f0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp ole float %[[#LHS]], %{{.+}}
@@ -690,13 +690,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ole float %[[#LHS]], %{{.+}}
 
   test = (f2 <= h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ole float %{{.+}}, %[[#RHS]]
@@ -705,13 +705,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp ole float %{{.+}}, %[[#RHS]]
 
   test = (i0 <= h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM: %{{.+}} = fcmp ole half %[[#LHS]], %{{.+}}
@@ -720,13 +720,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp ole half %[[#LHS]], %{{.+}}
 
   test = (h0 <= i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp ole half %{{.+}}, %[[#RHS]]
@@ -736,11 +736,11 @@ void foo(void) {
 
   test = (h0 >= h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
   // NONATIVE-NEXT: %{{.+}} = cir.get_global @test : !cir.ptr<!u32i>
 
   //      NATIVE: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oge half %{{.+}}, %{{.+}}
 
@@ -749,28 +749,28 @@ void foo(void) {
   test = (h0 >= (_Float16)-2.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   // NONATIVE-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#D]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#D]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   // NATIVE-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#D]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#D]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oge half %{{.+}}, 0xHC000
 
   // NATIVE-LLVM: %{{.+}} = fcmp oge half %{{.+}}, 0xHC000
 
   test = (h0 >= f2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp oge float %[[#LHS]], %{{.+}}
@@ -779,13 +779,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oge float %[[#LHS]], %{{.+}}
 
   test = (f0 >= h2);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp oge float %{{.+}}, %[[#RHS]]
@@ -794,13 +794,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp oge float %{{.+}}, %[[#RHS]]
 
   test = (i0 >= h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM: %{{.+}} = fcmp oge half %[[#LHS]], %{{.+}}
@@ -809,13 +809,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oge half %[[#LHS]], %{{.+}}
 
   test = (h0 >= i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp oge half %{{.+}}, %[[#RHS]]
@@ -825,10 +825,10 @@ void foo(void) {
 
   test = (h1 == h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, %{{.+}}
 
@@ -836,27 +836,27 @@ void foo(void) {
 
   test = (h1 == (_Float16)1.0);
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NONATIVE-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, 0xH3C00
 
   // NATIVE-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, 0xH3C00
 
   test = (h1 == f1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq float %[[#LHS]], %{{.+}}
@@ -865,13 +865,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oeq float %[[#LHS]], %{{.+}}
 
   test = (f1 == h1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp oeq float %{{.+}}, %[[#RHS]]
@@ -880,13 +880,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp oeq float %{{.+}}, %[[#RHS]]
 
   test = (i0 == h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM: %{{.+}} = fcmp oeq half %[[#LHS]], %{{.+}}
@@ -895,13 +895,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp oeq half %[[#LHS]], %{{.+}}
 
   test = (h0 == i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM-NEXT: %{{.=}} = fcmp oeq half %{{.+}}, %[[#RHS]]
@@ -911,37 +911,37 @@ void foo(void) {
 
   test = (h1 != h2);
   //      NONATIVE: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp une half %{{.+}}, %{{.+}}
 
   // NATIVE-LLVM: %{{.+}} = fcmp une half %{{.+}}, %{{.+}}
 
   test = (h1 != (_Float16)1.0);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.double), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.double -> !cir.f16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // NATIVE-NEXT: %[[#C:]] = cir.cmp(ne, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %{{.+}} = fcmp une half %{{.+}}, 0xH3C00
 
   // NATIVE-LLVM: %{{.+}} = fcmp une half %{{.+}}, 0xH3C00
 
   test = (h1 != f1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NONATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      NATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM: %{{.+}} = fcmp une float %[[#LHS]], %{{.+}}
@@ -950,13 +950,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp une float %[[#LHS]], %{{.+}}
 
   test = (f1 != h1);
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#A:]] = fpext half %{{.+}} to float
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp une float %{{.+}}, %[[#A]]
@@ -965,13 +965,13 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp une float %{{.+}}, %[[#A]]
 
   test = (i0 != h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NONATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // NONATIVE-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM: %{{.+}} = fcmp une half %[[#LHS]], %{{.+}}
@@ -980,13 +980,13 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fcmp une half %[[#LHS]], %{{.+}}
 
   test = (h0 != i0);
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NONATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NONATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NONATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // NATIVE-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // NATIVE-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      NONATIVE-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // NONATIVE-LLVM-NEXT: %{{.+}} = fcmp une half %{{.+}}, %[[#RHS]]
@@ -995,7 +995,7 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fcmp une half %{{.+}}, %[[#RHS]]
 
   h1 = (h1 ? h2 : h0);
-  //      NONATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.f16), !cir.bool
+  //      NONATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.f16 -> !cir.bool
   // NONATIVE-NEXT: %{{.+}} = cir.ternary(%[[#A]], true {
   //      NONATIVE:   cir.yield %{{.+}} : !cir.f16
   // NONATIVE-NEXT: }, false {
@@ -1003,7 +1003,7 @@ void foo(void) {
   // NONATIVE-NEXT: }) : (!cir.bool) -> !cir.f16
   //      NONATIVE: %{{.+}} = cir.get_global @h1 : !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.f16), !cir.bool
+  //      NATIVE: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.f16 -> !cir.bool
   // NATIVE-NEXT: %[[#B:]] = cir.ternary(%[[#A]], true {
   //      NATIVE:   cir.yield %{{.+}} : !cir.f16
   // NATIVE-NEXT: }, false {
@@ -1054,13 +1054,13 @@ void foo(void) {
   h0 = (_Float16)-2.0f;
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1071,13 +1071,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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
   //      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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1092,13 +1092,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: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast int_to_float %[[#B]] : !s32i -> !cir.f16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @i0 : !cir.ptr<!s32i>
   // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!s32i>, !s32i
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast int_to_float %[[#B]] : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1113,13 +1113,13 @@ void foo(void) {
   i0 = h0;
   //      NONATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !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.f16>
   // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @i0 : !cir.ptr<!s32i>
   // NATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !s32i, !cir.ptr<!s32i>
 
@@ -1132,10 +1132,10 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: store volatile i32 %[[#B]], ptr @i0, align 4
 
   h0 += h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(add, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.binop(add, %{{.+}}, %{{.+}}) : !cir.f16
@@ -1150,15 +1150,15 @@ void foo(void) {
 
   h0 += (_Float16)1.0f;
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.float
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.float), !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#D:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.float -> !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#D:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#E:]] = cir.binop(add, %[[#D]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %[[#F:]] = cir.cast(floating, %[[#E]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#F:]] = cir.cast floating %[[#E]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#F]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.float
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.float -> !cir.f16
   //      NATIVE: %[[#C:]] = cir.binop(add, %{{.+}}, %[[#B]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1169,14 +1169,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd half %{{.+}}, 0xH3C00
 
   h0 += f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -1188,15 +1188,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 += h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(add, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
@@ -1209,14 +1209,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 += i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(add, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#E]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1230,10 +1230,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fadd half %{{.+}}, %[[#A]]
 
   h0 -= h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(sub, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.binop(sub, %{{.+}}, %{{.+}}) : !cir.f16
@@ -1247,15 +1247,15 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub half %{{.+}}, %{{.+}}
 
   h0 -= (_Float16)1.0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.double), !cir.f16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.double -> !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(sub, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#E]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      NATIVE: %[[#C:]] = cir.binop(sub, %{{.+}}, %[[#B]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1266,14 +1266,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub half %{{.+}}, 0xH3C00
 
   h0 -= f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -1285,15 +1285,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 -= h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(sub, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
@@ -1306,14 +1306,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 -= i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(sub, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#E]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1327,10 +1327,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fsub half %{{.+}}, %[[#A]]
 
   h0 *= h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(mul, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.binop(mul, %{{.+}}, %{{.+}}) : !cir.f16
@@ -1344,15 +1344,15 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul half %{{.+}}, %{{.+}}
 
   h0 *= (_Float16)1.0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.double), !cir.f16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.double -> !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(mul, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#E]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      NATIVE: %[[#C:]] = cir.binop(mul, %{{.+}}, %[[#B]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1363,14 +1363,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul half %{{.+}}, 0xH3C00
 
   h0 *= f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -1382,15 +1382,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 *= h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(mul, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
@@ -1403,14 +1403,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 *= i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(mul, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#E]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1424,10 +1424,10 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fmul half %{{.+}}, %[[#A]]
 
   h0 /= h1;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(div, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.binop(div, %{{.+}}, %{{.+}}) : !cir.f16
@@ -1442,15 +1442,15 @@ void foo(void) {
 
   h0 /= (_Float16)1.0;
   //      NONATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#D:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#D:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#E:]] = cir.binop(div, %[[#D]], %[[#C]]) : !cir.float
-  // NONATIVE-NEXT: %[[#F:]] = cir.cast(floating, %[[#E]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#F:]] = cir.cast floating %[[#E]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#F]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // NATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      NATIVE: %[[#C:]] = cir.binop(div, %{{.+}}, %[[#B]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1461,14 +1461,14 @@ void foo(void) {
   // NATIVE-LLVM: %{{.+}} = fdiv half %{{.+}}, 0xH3C00
 
   h0 /= f2;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NATIVE-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NONATIVE-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -1480,15 +1480,15 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 /= h0;
-  //      NONATIVE: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //      NONATIVE: %[[#B:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#B:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.float
   // NONATIVE-NEXT: %[[#C:]] = cir.binop(div, %[[#B]], %[[#A]]) : !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(float_to_int, %[[#C]] : !cir.float), !s32i
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast float_to_int %[[#C]] : !cir.float -> !s32i
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // NATIVE-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // NATIVE-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // NATIVE-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      NONATVE-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
@@ -1501,14 +1501,14 @@ void foo(void) {
   // NATIVE-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 /= i0;
-  //      NONATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
-  // NONATIVE-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.f16), !cir.float
-  //      NONATIVE: %[[#C:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      NONATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
+  // NONATIVE-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.f16 -> !cir.float
+  //      NONATIVE: %[[#C:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // NONATIVE-NEXT: %[[#D:]] = cir.binop(div, %[[#C]], %[[#B]]) : !cir.float
-  // NONATIVE-NEXT: %[[#E:]] = cir.cast(floating, %[[#D]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#E:]] = cir.cast floating %[[#D]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: cir.store volatile %[[#E]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
-  //      NATIVE: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      NATIVE: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      NATIVE: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.f16
   // NATIVE-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1524,13 +1524,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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
   //      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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1545,15 +1545,15 @@ 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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.float
+  // NONATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // NONATIVE-NEXT: %[[#E:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: cir.store volatile %[[#D]], %[[#E]] : !cir.f16, !cir.ptr<!cir.f16>
 
   //      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: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
-  // NATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.float
+  // NATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // NATIVE-NEXT: %[[#E:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NATIVE-NEXT: cir.store volatile %[[#D]], %[[#E]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -1570,13 +1570,13 @@ void foo(void) {
   d0 = h0;
   //      NONATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.double
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !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.f16>
   // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.double
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !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>
 
@@ -1591,15 +1591,15 @@ void foo(void) {
   d0 = (float)h0;
   //      NONATIVE: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // NONATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
-  // NONATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !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.f16>
   // NATIVE-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
-  // NATIVE-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
+  // NATIVE-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
+  // NATIVE-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.double
   // NATIVE-NEXT: %[[#E:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // NATIVE-NEXT: cir.store volatile %[[#D]], %[[#E]] : !cir.double, !cir.ptr<!cir.double>
 
@@ -1616,13 +1616,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: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.f16
+  // NONATIVE-NEXT: %[[#C:]] = cir.cast int_to_float %[[#B]] : !s16i -> !cir.f16
   // NONATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NONATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
   //      NATIVE: %[[#A:]] = cir.get_global @s0 : !cir.ptr<!s16i>
   // NATIVE-NEXT: %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!s16i>, !s16i
-  // NATIVE-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.f16
+  // NATIVE-NEXT: %[[#C:]] = cir.cast int_to_float %[[#B]] : !s16i -> !cir.f16
   // NATIVE-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // NATIVE-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
diff --git a/clang/test/CIR/CodeGen/fp16-ops.c b/clang/test/CIR/CodeGen/fp16-ops.c
index 708d5db1dde0..8a0302fe93e9 100644
--- a/clang/test/CIR/CodeGen/fp16-ops.c
+++ b/clang/test/CIR/CodeGen/fp16-ops.c
@@ -16,20 +16,20 @@ short s0;
 
 void foo(void) {
   test = (h0);
-  // CHECK: %{{.+}} = cir.cast(float_to_int, %{{.+}} : !cir.f16), !u32i
+  // CHECK: %{{.+}} = cir.cast float_to_int %{{.+}} : !cir.f16 -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fptoui half %{{.+}} to i32
 
   h0 = (test);
-  // CHECK: %{{.+}} = cir.cast(int_to_float, %{{.+}} : !u32i), !cir.f16
+  // CHECK: %{{.+}} = cir.cast int_to_float %{{.+}} : !u32i -> !cir.f16
 
   // CHECK-LLVM: %{{.+}} = uitofp i32 %{{.+}} to half
 
   test = (!h1);
-  //      CHECK: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.f16), !cir.bool
+  //      CHECK: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.f16 -> !cir.bool
   // CHECK-NEXT: %[[#B:]] = cir.unary(not, %[[#A]]) : !cir.bool, !cir.bool
-  // CHECK-NEXT: %[[#C:]] = cir.cast(bool_to_int, %[[#B]] : !cir.bool), !s32i
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // CHECK-NEXT: %[[#C:]] = cir.cast bool_to_int %[[#B]] : !cir.bool -> !s32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#A:]] = fcmp une half %{{.+}}, 0xH0000
   // CHECK-LLVM-NEXT: %[[#B:]] = zext i1 %[[#A]] to i8
@@ -37,15 +37,15 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = zext i8 %[[#C]] to i32
 
   h1 = -h1;
-  //  CHECK-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //  CHECK-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.float), !cir.f16
+  //  CHECK-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //  CHECK-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.float -> !cir.f16
   //      CHECK: %{{.+}} = cir.unary(minus, %{{.+}}) : !cir.f16, !cir.f16
 
   // CHECK-LLVM: %{{.+}} = fneg half %{{.+}}
 
   h1 = +h1;
-  //  CHECK-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
-  //  CHECK-NOT: %{{.+}} = cir.cast(floating, %{{.+}} : !cir.float), !cir.f16
+  //  CHECK-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
+  //  CHECK-NOT: %{{.+}} = cir.cast floating %{{.+}} : !cir.float -> !cir.f16
   //      CHECK: %{{.+}} = cir.unary(plus, %{{.+}}) : !cir.f16, !cir.f16
 
   //      CHECK-LLVM: %[[#A:]] = load volatile half, ptr @h1, align 2
@@ -83,31 +83,31 @@ void foo(void) {
   h1 = h0 * (__fp16) -2.0f;
   //      CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: %{{.+}} = cir.binop(mul, %{{.+}}, %[[#C]]) : !cir.f16
 
   // CHECK-LLVM: %{{.+}} = fmul half %{{.+}}, 0xHC000
 
   h1 = h0 * f2;
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      CHECK-LLVM: %[[#RES:]] = fmul float %[[#LHS]], %{{.+}}
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = f0 * h2;
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %[[#RES:]] = fmul float %{{.+}}, %[[#RHS]]
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = h0 * i0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %{{.+}} = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -121,31 +121,31 @@ void foo(void) {
   h1 = (h0 / (__fp16) -2.0f);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: %{{.+}} = cir.binop(div, %{{.+}}, %[[#C]]) : !cir.f16
 
   // CHECK-LLVM: %{{.+}} = fdiv half %{{.+}}, 0xHC000
 
   h1 = (h0 / f2);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      CHECK-LLVM: %[[#RES:]] = fdiv float %[[#LHS]], %{{.+}}
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (f0 / h2);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %[[#RES:]] = fdiv float %{{.+}}, %[[#RHS]]
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (h0 / i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %{{.+}} = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -159,31 +159,31 @@ void foo(void) {
   h1 = ((__fp16)-2.0 + h0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   //      CHECK: %{{.+}} = cir.binop(add, %[[#C]], %{{.+}}) : !cir.f16
 
   // CHECK-LLVM: %{{.+}} = fadd half 0xHC000, %{{.+}}
 
   h1 = (h2 + f0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      CHECK-LLVM: %[[#RES:]] = fadd float %[[#LHS]], %{{.+}}
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (f2 + h0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.=}} to float
   // CHECK-LLVM-NEXT: %[[#RES:]] = fadd float %{{.+}}, %[[#RHS]]
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (h0 + i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %{{.+}} = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -197,31 +197,31 @@ void foo(void) {
   h1 = ((__fp16)-2.0f - h0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   //      CHECK: %{{.+}} = cir.binop(sub, %[[#C]], %{{.+}}) : !cir.f16
 
   // CHECK-LLVM: %{{.+}} = fsub half 0xHC000, %{{.+}}
 
   h1 = (h2 - f0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   //      CHECK-LLVM: %[[#RES:]] = fsub float %[[#LHS]], %{{.+}}
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (f2 - h0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.float
-  // CHECK-NEXT: %{{.+}} = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %{{.+}} = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.=}} to float
   // CHECK-LLVM-NEXT: %[[#RES:]] = fsub float %{{.+}}, %[[#RHS]]
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   h1 = (h0 - i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %{{.+}} = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.f16
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -229,283 +229,283 @@ void foo(void) {
 
   test = (h2 < h0);
   //      CHECK: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp olt half %{{.+}}, %{{.+}}
 
   test = (h2 < (__fp16)42.0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // CHECK-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp olt half %{{.+}}, 0xH5140
 
   test = (h2 < f0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#A:]] = fpext half %{{.+}} to float
   // CHECK-LLVM: %{{.+}} = fcmp olt float %[[#A]], %{{.+}}
 
   test = (f2 < h0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#A:]] = fpext half %{{.=}} to float
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp olt float %{{.+}}, %[[#A]]
 
   test = (i0 < h0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM: %{{.+}} = fcmp olt half %[[#A]], %{{.+}}
 
   test = (h0 < i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp olt half %{{.+}}, %[[#A]]
 
   test = (h0 > h2);
   //      CHECK: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp ogt half %{{.+}}, %{{.+}}
 
   test = ((__fp16)42.0 > h2);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      CHECK: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp ogt half 0xH5140, %{{.+}}
 
   test = (h0 > f2);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = fpext half %{{.=}} to float
   // CHECK-LLVM: %{{.+}} = fcmp ogt float %[[#LHS]], %{{.+}}
 
   test = (f0 > h2);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp ogt float %{{.+}}, %[[#RHS]]
 
   test = (i0 > h0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM: %{{.+}} = fcmp ogt half %[[#LHS]], %{{.+}}
 
   test = (h0 > i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp ogt half %{{.+}}, %[[#RHS]]
 
   test = (h2 <= h0);
   //      CHECK: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp ole half %{{.+}}, %{{.+}}
 
   test = (h2 <= (__fp16)42.0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // CHECK-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp ole half %{{.+}}, 0xH5140
 
   test = (h2 <= f0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM: %{{.+}} = fcmp ole float %[[#LHS]], %{{.+}}
 
   test = (f2 <= h0);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp ole float %{{.+}}, %[[#RHS]]
 
   test = (i0 <= h0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM: %{{.+}} = fcmp ole half %[[#LHS]], %{{.+}}
 
   test = (h0 <= i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp ole half %{{.+}}, %[[#RHS]]
 
   test = (h0 >= h2);
   //      CHECK: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp oge half %{{.+}}, %{{.+}}
 
   test = (h0 >= (__fp16)-2.0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
   // CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   // CHECK-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#D]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#D]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp oge half %{{.+}}, 0xHC000
 
   test = (h0 >= f2);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM: %{{.+}} = fcmp oge float %[[#LHS]], %{{.+}}
 
   test = (f0 >= h2);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp oge float %{{.+}}, %[[#RHS]]
 
   test = (i0 >= h0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM: %{{.+}} = fcmp oge half %[[#LHS]], %{{.+}}
 
   test = (h0 >= i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp oge half %{{.+}}, %[[#RHS]]
 
   test = (h1 == h2);
   //      CHECK: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, %{{.+}}
 
   test = (h1 == (__fp16)1.0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // CHECK-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, 0xH3C00
 
   test = (h1 == f1);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM: %{{.+}} = fcmp oeq float %[[#LHS]], %{{.+}}
 
   test = (f1 == h1);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp oeq float %{{.+}}, %[[#RHS]]
 
   test = (i0 == h0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM: %{{.+}} = fcmp oeq half %[[#LHS]], %{{.+}}
 
   test = (h0 == i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM-NEXT: %{{.=}} = fcmp oeq half %{{.+}}, %[[#RHS]]
 
   test = (h1 != h2);
   //      CHECK: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#A]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp une half %{{.+}}, %{{.+}}
 
   test = (h1 != (__fp16)1.0);
   //      CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   // CHECK-NEXT: %[[#C:]] = cir.cmp(ne, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#C]] : !s32i -> !u32i
 
   // CHECK-LLVM: %{{.+}} = fcmp une half %{{.+}}, 0xH3C00
 
   test = (h1 != f1);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   //      CHECK: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = fpext half %{{.=}} to float
   // CHECK-LLVM: %{{.+}} = fcmp une float %[[#LHS]], %{{.+}}
 
   test = (f1 != h1);
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#A:]] = fpext half %{{.+}} to float
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp une float %{{.+}}, %[[#A]]
 
   test = (i0 != h0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   // CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM: %{{.+}} = fcmp une half %[[#LHS]], %{{.+}}
 
   test = (h0 != i0);
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
-  // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
+  // CHECK-NEXT: %{{.+}} = cir.cast integral %[[#B]] : !s32i -> !u32i
 
   //      CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
   // CHECK-LLVM-NEXT: %{{.+}} = fcmp une half %{{.+}}, %[[#RHS]]
 
   h1 = (h1 ? h2 : h0);
-  //      CHECK: %[[#A:]] = cir.cast(float_to_bool, %{{.+}} : !cir.f16), !cir.bool
+  //      CHECK: %[[#A:]] = cir.cast float_to_bool %{{.+}} : !cir.f16 -> !cir.bool
   // CHECK-NEXT: %[[#B:]] = cir.ternary(%[[#A]], true {
   //      CHECK:   cir.yield %{{.+}} : !cir.f16
   // CHECK-NEXT: }, false {
@@ -537,7 +537,7 @@ void foo(void) {
   h0 = (__fp16)-2.0f;
   //      CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.float, !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -546,7 +546,7 @@ void foo(void) {
   h0 = f0;
   //      CHECK: %[[#A:]] = cir.get_global @f0 : !cir.ptr<!cir.float>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.float>, !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -557,7 +557,7 @@ void foo(void) {
   h0 = i0;
   //      CHECK: %[[#A:]] = cir.get_global @i0 : !cir.ptr<!s32i>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!s32i>, !s32i
-  // CHECK-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s32i), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast int_to_float %[[#B]] : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -568,7 +568,7 @@ void foo(void) {
   i0 = h0;
   //      CHECK: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // CHECK-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // CHECK-NEXT: %[[#D:]] = cir.get_global @i0 : !cir.ptr<!s32i>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !s32i, !cir.ptr<!s32i>
 
@@ -584,16 +584,16 @@ void foo(void) {
 
   h0 += (__fp16)1.0f;
   //      CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.float
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.float -> !cir.f16
   //      CHECK: %[[#C:]] = cir.binop(add, %{{.+}}, %[[#B]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   // CHECK-LLVM: %{{.+}} = fadd half %{{.+}}, 0xH3C00
 
   h0 += f2;
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -601,9 +601,9 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 += h0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.binop(add, %[[#A]], %{{.+}}) : !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // CHECK-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -611,7 +611,7 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 += i0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.binop(add, %{{.+}}, %[[#A]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -626,16 +626,16 @@ void foo(void) {
 
   h0 -= (__fp16)1.0;
   //      CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      CHECK: %[[#C:]] = cir.binop(sub, %{{.+}}, %[[#B]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   // CHECK-LLVM: %{{.+}} = fsub half %{{.+}}, 0xH3C00
 
   h0 -= f2;
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -643,9 +643,9 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 -= h0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.binop(sub, %[[#A]], %{{.+}}) : !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // CHECK-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -653,7 +653,7 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 -= i0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.binop(sub, %{{.+}}, %[[#A]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -668,16 +668,16 @@ void foo(void) {
 
   h0 *= (__fp16)1.0;
   //      CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      CHECK: %[[#C:]] = cir.binop(mul, %{{.+}}, %[[#B]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   // CHECK-LLVM: %{{.+}} = fmul half %{{.+}}, 0xH3C00
 
   h0 *= f2;
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -685,9 +685,9 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 *= h0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.binop(mul, %[[#A]], %{{.+}}) : !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // CHECK-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -695,7 +695,7 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 *= i0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.binop(mul, %{{.+}}, %[[#A]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -710,16 +710,16 @@ void foo(void) {
 
   h0 /= (__fp16)1.0;
   //      CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
-  // CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#B:]] = cir.cast floating %[[#A]] : !cir.double -> !cir.f16
   //      CHECK: %[[#C:]] = cir.binop(div, %{{.+}}, %[[#B]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   // CHECK-LLVM: %{{.+}} = fdiv half %{{.+}}, 0xH3C00
 
   h0 /= f2;
-  //      CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
+  //      CHECK: %[[#A:]] = cir.cast floating %{{.+}} : !cir.f16 -> !cir.float
   // CHECK-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.float
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.float -> !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
   //      CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
@@ -727,9 +727,9 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptrunc float %[[#RES]] to half
 
   i0 /= h0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   // CHECK-NEXT: %[[#B:]] = cir.binop(div, %[[#A]], %{{.+}}) : !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(float_to_int, %[[#B]] : !cir.f16), !s32i
+  // CHECK-NEXT: %[[#C:]] = cir.cast float_to_int %[[#B]] : !cir.f16 -> !s32i
   // CHECK-NEXT: cir.store volatile %[[#C]], %{{.+}} : !s32i, !cir.ptr<!s32i>
 
   //      CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
@@ -737,7 +737,7 @@ void foo(void) {
   // CHECK-LLVM-NEXT: %{{.+}} = fptosi half %[[#B]] to i32
 
   h0 /= i0;
-  //      CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
+  //      CHECK: %[[#A:]] = cir.cast int_to_float %{{.+}} : !s32i -> !cir.f16
   //      CHECK: %[[#B:]] = cir.binop(div, %{{.+}}, %[[#A]]) : !cir.f16
   // CHECK-NEXT: cir.store volatile %[[#B]], %{{.+}} : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -747,7 +747,7 @@ void foo(void) {
   h0 = d0;
   //      CHECK: %[[#A:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.double>, !cir.double
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.f16
   // CHECK-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -758,8 +758,8 @@ void foo(void) {
   h0 = (float)d0;
   //      CHECK: %[[#A:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.double>, !cir.double
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.float
-  // CHECK-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.double -> !cir.float
+  // CHECK-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.f16
   // CHECK-NEXT: %[[#E:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: cir.store volatile %[[#D]], %[[#E]] : !cir.f16, !cir.ptr<!cir.f16>
 
@@ -771,7 +771,7 @@ void foo(void) {
   d0 = h0;
   //      CHECK: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.double
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.double
   // CHECK-NEXT: %[[#D:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.double, !cir.ptr<!cir.double>
 
@@ -782,8 +782,8 @@ void foo(void) {
   d0 = (float)h0;
   //      CHECK: %[[#A:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: %[[#B:]] = cir.load volatile %[[#A]] : !cir.ptr<!cir.f16>, !cir.f16
-  // CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.f16), !cir.float
-  // CHECK-NEXT: %[[#D:]] = cir.cast(floating, %[[#C]] : !cir.float), !cir.double
+  // CHECK-NEXT: %[[#C:]] = cir.cast floating %[[#B]] : !cir.f16 -> !cir.float
+  // CHECK-NEXT: %[[#D:]] = cir.cast floating %[[#C]] : !cir.float -> !cir.double
   // CHECK-NEXT: %[[#E:]] = cir.get_global @d0 : !cir.ptr<!cir.double>
   // CHECK-NEXT: cir.store volatile %[[#D]], %[[#E]] : !cir.double, !cir.ptr<!cir.double>
 
@@ -795,7 +795,7 @@ void foo(void) {
   h0 = s0;
   //      CHECK: %[[#A:]] = cir.get_global @s0 : !cir.ptr<!s16i>
   // CHECK-NEXT: %[[#B:]] = cir.load %[[#A]] : !cir.ptr<!s16i>, !s16i
-  // CHECK-NEXT: %[[#C:]] = cir.cast(int_to_float, %[[#B]] : !s16i), !cir.f16
+  // CHECK-NEXT: %[[#C:]] = cir.cast int_to_float %[[#B]] : !s16i -> !cir.f16
   // CHECK-NEXT: %[[#D:]] = cir.get_global @h0 : !cir.ptr<!cir.f16>
   // CHECK-NEXT: cir.store volatile %[[#C]], %[[#D]] : !cir.f16, !cir.ptr<!cir.f16>
 
diff --git a/clang/test/CIR/CodeGen/function-to-pointer-decay.c b/clang/test/CIR/CodeGen/function-to-pointer-decay.c
index c8541ceb3d09..781d1fba705f 100644
--- a/clang/test/CIR/CodeGen/function-to-pointer-decay.c
+++ b/clang/test/CIR/CodeGen/function-to-pointer-decay.c
@@ -8,6 +8,6 @@ void test_call_lvalue_cast() {
 
 // CHECK: cir.func {{.*}}@test_call_lvalue_cast()
 // CHECK: [[F:%.+]] = cir.get_global @f
-// CHECK: [[CASTED:%.+]] = cir.cast(bitcast, [[F]]
+// CHECK: [[CASTED:%.+]] = cir.cast bitcast [[F]]
 // CHECK: [[CONST:%.+]] = cir.const #cir.int<42>
 // CHECK: cir.call [[CASTED]]([[CONST]])
diff --git a/clang/test/CIR/CodeGen/global-new.cpp b/clang/test/CIR/CodeGen/global-new.cpp
index 7f7d2af9464f..9e2beb656099 100644
--- a/clang/test/CIR/CodeGen/global-new.cpp
+++ b/clang/test/CIR/CodeGen/global-new.cpp
@@ -18,7 +18,7 @@ e *g = new e(0);
 // CIR_BEFORE:     %[[GlobalAddr:.*]] = cir.get_global @g : !cir.ptr<!cir.ptr<![[ty]]>>
 // CIR_BEFORE:     %[[Size:.*]] = cir.const #cir.int<1> : !u64i
 // CIR_BEFORE:     %[[NewAlloc:.*]] = cir.call @_Znwm(%[[Size]]) : (!u64i) -> !cir.ptr<!void>
-// CIR_BEFORE:     %[[NewCasted:.*]] = cir.cast(bitcast, %[[NewAlloc]] : !cir.ptr<!void>), !cir.ptr<![[ty]]>
+// CIR_BEFORE:     %[[NewCasted:.*]] = cir.cast bitcast %[[NewAlloc]] : !cir.ptr<!void> -> !cir.ptr<![[ty]]>
 // CIR_BEFORE:     %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
 // CIR_BEFORE:     cir.call @_ZN1eC1Ei(%[[NewCasted]], %[[ZERO]]) : (!cir.ptr<![[ty]]>, !s32i) -> ()
 // CIR_BEFORE:     cir.store{{.*}} %3, %[[GlobalAddr]] : !cir.ptr<![[ty]]>, !cir.ptr<!cir.ptr<![[ty]]>>
diff --git a/clang/test/CIR/CodeGen/globals.cpp b/clang/test/CIR/CodeGen/globals.cpp
index f3c2527428e5..c52101cef60d 100644
--- a/clang/test/CIR/CodeGen/globals.cpp
+++ b/clang/test/CIR/CodeGen/globals.cpp
@@ -74,7 +74,7 @@ int use_func() { return func<int>(); }
 // CHECK-NEXT:   %3 = cir.const #cir.int<0> : !s32i
 // CHECK-NEXT:   %4 = cir.ptr_stride %2, %3 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
 // CHECK-NEXT:   %5 = cir.load{{.*}} %4 : !cir.ptr<!s8i>, !s8i
-// CHECK-NEXT:   %6 = cir.cast(integral, %5 : !s8i), !u8i
+// CHECK-NEXT:   %6 = cir.cast integral %5 : !s8i -> !u8i
 // CHECK-NEXT:   cir.store{{.*}} %6, %0 : !u8i, !cir.ptr<!u8i>
 // CHECK-NEXT:   cir.return
 
@@ -109,19 +109,19 @@ void get_globals() {
   // CHECK: cir.func dso_local @_Z11get_globalsv()
   char *s = string;
   // CHECK: %[[RES:[0-9]+]] = cir.get_global @string : !cir.ptr<!cir.array<!s8i x 8>>
-  // CHECK: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %[[RES]] : !cir.ptr<!cir.array<!s8i x 8>>), !cir.ptr<!s8i>
+  // CHECK: %{{[0-9]+}} = cir.cast array_to_ptrdecay %[[RES]] : !cir.ptr<!cir.array<!s8i x 8>> -> !cir.ptr<!s8i>
   unsigned *u = uint;
   // CHECK: %[[RES:[0-9]+]] = cir.get_global @uint : !cir.ptr<!cir.array<!u32i x 1>>
-  // CHECK: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %[[RES]] : !cir.ptr<!cir.array<!u32i x 1>>), !cir.ptr<!u32i>
+  // CHECK: %{{[0-9]+}} = cir.cast array_to_ptrdecay %[[RES]] : !cir.ptr<!cir.array<!u32i x 1>> -> !cir.ptr<!u32i>
   short *ss = sshort;
   // CHECK: %[[RES:[0-9]+]] = cir.get_global @sshort : !cir.ptr<!cir.array<!s16i x 2>>
-  // CHECK: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %[[RES]] : !cir.ptr<!cir.array<!s16i x 2>>), !cir.ptr<!s16i>
+  // CHECK: %{{[0-9]+}} = cir.cast array_to_ptrdecay %[[RES]] : !cir.ptr<!cir.array<!s16i x 2>> -> !cir.ptr<!s16i>
   int *si = sint;
   // CHECK: %[[RES:[0-9]+]] = cir.get_global @sint : !cir.ptr<!cir.array<!s32i x 3>>
-  // CHECK: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %[[RES]] : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
+  // CHECK: %{{[0-9]+}} = cir.cast array_to_ptrdecay %[[RES]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
   long long *l = ll;
   // CHECK: %[[RES:[0-9]+]] = cir.get_global @ll : !cir.ptr<!cir.array<!s64i x 4>>
-  // CHECK: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %[[RES]] : !cir.ptr<!cir.array<!s64i x 4>>), !cir.ptr<!s64i>
+  // CHECK: %{{[0-9]+}} = cir.cast array_to_ptrdecay %[[RES]] : !cir.ptr<!cir.array<!s64i x 4>> -> !cir.ptr<!s64i>
 }
 
 // Should generate extern global variables.
diff --git a/clang/test/CIR/CodeGen/hello.c b/clang/test/CIR/CodeGen/hello.c
index ab937901bad7..84d30b32811a 100644
--- a/clang/test/CIR/CodeGen/hello.c
+++ b/clang/test/CIR/CodeGen/hello.c
@@ -13,7 +13,7 @@ int main (void) {
 // CHECK:   %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
 // CHECK:   %1 = cir.get_global @printf : !cir.ptr<!cir.func<(!cir.ptr<!s8i>, ...) -> !s32i>>
 // CHECK:   %2 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 15>>
-// CHECK:   %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!s8i x 15>>), !cir.ptr<!s8i>
+// CHECK:   %3 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!s8i x 15>> -> !cir.ptr<!s8i>
 // CHECK:   %4 = cir.call @printf(%3) : (!cir.ptr<!s8i>) -> !s32i
 // CHECK:   %5 = cir.const #cir.int<0> : !s32i
 // CHECK:   cir.store %5, %0 : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp b/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp
index 8e1b3c2f32bf..c439d8a3ce33 100644
--- a/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp
+++ b/clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp
@@ -31,20 +31,20 @@ void test() {
 // CIR: [[ZERO:%.*]] = cir.const #cir.int<0>
 // CIR: [[FIRST_ELEM_PTR:%.*]] = cir.get_element [[LOCAL_ELEM_ARRAY]][[[ZERO]]] : (!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, !s32i) -> !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[XY_CHAR_ARRAY:%.*]] = cir.get_global [[STR_XY]]  : !cir.ptr<!cir.array<!s8i x 3>>
-// CIR: [[STR_XY_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[XY_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
+// CIR: [[STR_XY_PTR:%.*]] = cir.cast array_to_ptrdecay [[XY_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>> -> !cir.ptr<!s8i>
 // CIR:  cir.store{{.*}} [[STR_XY_PTR]], [[FIRST_ELEM_PTR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[ONE:%.*]] = cir.const #cir.int<1>
 // CIR: [[NEXT_ELEM_PTR:%.*]] = cir.get_element [[LOCAL_ELEM_ARRAY]][[[ONE]]] : (!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, !s64i) -> !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[UV_CHAR_ARRAY:%.*]] = cir.get_global [[STR_UV]]  : !cir.ptr<!cir.array<!s8i x 3>>
-// CIR: [[STR_UV_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[UV_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
+// CIR: [[STR_UV_PTR:%.*]] = cir.cast array_to_ptrdecay [[UV_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>> -> !cir.ptr<!s8i>
 // CIR:  cir.store{{.*}} [[STR_UV_PTR]], [[NEXT_ELEM_PTR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[START_FLD_PTR:%.*]] = cir.get_member [[INITLIST_LOCAL]][0] {name = "array_start"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
-// CIR: [[START_FLD_PTR_AS_PTR_2_CHAR_ARRAY:%.*]] = cir.cast(bitcast, [[START_FLD_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>), !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
+// CIR: [[START_FLD_PTR_AS_PTR_2_CHAR_ARRAY:%.*]] = cir.cast bitcast [[START_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]], [[START_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: [[ELEM_ARRAY_LEN:%.*]] = cir.const #cir.int<2>
 // CIR: [[END_FLD_PTR:%.*]] = cir.get_member [[INITLIST_LOCAL]][1] {name = "array_end"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
 // CIR: [[LOCAL_ELEM_ARRAY_END:%.*]] = cir.ptr_stride [[LOCAL_ELEM_ARRAY]], [[ELEM_ARRAY_LEN]] : (!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, !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: [[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: cir.call @_ZSt1fIPKcEvSt16initializer_listIT_E([[ARG]]) : ([[INITLIST_TYPE]]) -> ()
diff --git a/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp b/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp
index 3bb0b08e07f8..7d4c509ad152 100644
--- a/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp
+++ b/clang/test/CIR/CodeGen/initlist-ptr-unsigned.cpp
@@ -31,7 +31,7 @@ void test() {
 // CIR: [[SEVEN:%.*]] = cir.const #cir.int<7> : !s32i
 // CIR: cir.store{{.*}} [[SEVEN]], [[FIRST_ELEM]] : !s32i, !cir.ptr<!s32i>
 // CIR: [[FLD_C:%.*]] = cir.get_member [[LIST_PTR]][0] {name = "c"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: [[ARRAY_PTR:%.*]] = cir.cast(bitcast, [[FLD_C]] : !cir.ptr<!cir.ptr<!s32i>>), !cir.ptr<!cir.ptr<!cir.array<!s32i x 1>>>
+// CIR: [[ARRAY_PTR:%.*]] = cir.cast bitcast [[FLD_C]] : !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 1>>>
 // CIR: cir.store{{.*}} [[ARRAY]], [[ARRAY_PTR]] : !cir.ptr<!cir.array<!s32i x 1>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 1>>>
 // 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>
diff --git a/clang/test/CIR/CodeGen/int128.cpp b/clang/test/CIR/CodeGen/int128.cpp
index 5244b9d2fa62..515cff30bb5c 100644
--- a/clang/test/CIR/CodeGen/int128.cpp
+++ b/clang/test/CIR/CodeGen/int128.cpp
@@ -45,11 +45,11 @@ volatile double double_var;
 // LLVM-LABEL: @_Z19integral_conversionn
 __int128 integral_conversion(__int128 x) {
   int_var = x;
-  // CHECK: %[[#VAL:]] = cir.cast(integral, %{{.+}} : !s128i), !s32i
+  // CHECK: %[[#VAL:]] = cir.cast integral %{{.+}} : !s128i -> !s32i
   // LLVM: %{{.+}} = trunc i128 %{{.+}} to i32
 
   return int_var;
-  // CHECK: %{{.+}} = cir.cast(integral, %{{.+}} : !s32i), !s128i
+  // CHECK: %{{.+}} = cir.cast integral %{{.+}} : !s32i -> !s128i
   // LLVM: %{{.+}} = sext i32 %{{.+}} to i128
 }
 
@@ -57,11 +57,11 @@ __int128 integral_conversion(__int128 x) {
 // LLVM-LABEL: @_Z16float_conversionn
 __int128 float_conversion(__int128 x) {
   double_var = x;
-  // CHECK: %[[#VAL:]] = cir.cast(int_to_float, %{{.+}} : !s128i), !cir.double
+  // CHECK: %[[#VAL:]] = cir.cast int_to_float %{{.+}} : !s128i -> !cir.double
   // LLVM: %{{.+}} = sitofp i128 %{{.+}} to double
 
   return double_var;
-  // CHECK: %{{.+}} = cir.cast(float_to_int, %{{.+}} : !cir.double), !s128i
+  // CHECK: %{{.+}} = cir.cast float_to_int %{{.+}} : !cir.double -> !s128i
   // LLVM: %{{.+}} = fptosi double %{{.+}} to i128
 }
 
@@ -69,6 +69,6 @@ __int128 float_conversion(__int128 x) {
 // LLVM-LABEL: @_Z18boolean_conversionn
 bool boolean_conversion(__int128 x) {
   return x;
-  // CHECK: %{{.+}} = cir.cast(int_to_bool, %{{.+}} : !s128i), !cir.bool
+  // CHECK: %{{.+}} = cir.cast int_to_bool %{{.+}} : !s128i -> !cir.bool
   // LLVM: %{{.+}} = icmp ne i128 %{{.+}}, 0
 }
diff --git a/clang/test/CIR/CodeGen/kr-func-promote.c b/clang/test/CIR/CodeGen/kr-func-promote.c
index 78d629c71381..f34e11ce3e9e 100644
--- a/clang/test/CIR/CodeGen/kr-func-promote.c
+++ b/clang/test/CIR/CodeGen/kr-func-promote.c
@@ -2,12 +2,12 @@
 
 // CHECK: cir.func {{.*}}@foo(%arg0: !s32i
 // CHECK:   %0 = cir.alloca !s16i, !cir.ptr<!s16i>, ["x", init]
-// CHECK:   %1 = cir.cast(integral, %arg0 : !s32i)
+// CHECK:   %1 = cir.cast integral %arg0 : !s32i -> !s16i
 // CHECK:   cir.store %1, %0 : !s16i, !cir.ptr<!s16i>
 void foo(x) short x; {}
 
 // CHECK: cir.func no_proto dso_local @bar(%arg0: !cir.double
 // CHECK:   %0 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
-// CHECK:   %1 = cir.cast(floating, %arg0 : !cir.double), !cir.float
+// CHECK:   %1 = cir.cast floating %arg0 : !cir.double -> !cir.float
 // CHECK:   cir.store %1, %0 : !cir.float, !cir.ptr<!cir.float>
 void bar(f) float f; {}
diff --git a/clang/test/CIR/CodeGen/lalg.c b/clang/test/CIR/CodeGen/lalg.c
index 7a086e9d059d..14ebd807d002 100644
--- a/clang/test/CIR/CodeGen/lalg.c
+++ b/clang/test/CIR/CodeGen/lalg.c
@@ -13,7 +13,7 @@ double dot() {
 // CHECK-NEXT: %4 = cir.const #cir.fp<0.000000e+00> : !cir.double
 // CHECK-NEXT: cir.store{{.*}} %4, %1 : !cir.double, !cir.ptr<!cir.double>
 // 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: %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
diff --git a/clang/test/CIR/CodeGen/literals.c b/clang/test/CIR/CodeGen/literals.c
index b8a33ad11559..a2d8148fe19c 100644
--- a/clang/test/CIR/CodeGen/literals.c
+++ b/clang/test/CIR/CodeGen/literals.c
@@ -3,7 +3,7 @@
 int literals(void) {
     char a = 'a'; // char literals are int in C
     // CHECK: %[[RES:[0-9]+]] = cir.const #cir.int<97> : !s32i
-    // CHECK: %{{[0-9]+}} = cir.cast(integral, %[[RES]] : !s32i), !s8i
+    // CHECK: %{{[0-9]+}} = cir.cast integral %[[RES]] : !s32i -> !s8i
 
     return 0;
 }
diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp
index 7c87c4e5d1fe..5d2243ffa47e 100644
--- a/clang/test/CIR/CodeGen/loop.cpp
+++ b/clang/test/CIR/CodeGen/loop.cpp
@@ -85,7 +85,7 @@ void l2(bool cond) {
 // CHECK-NEXT:   cir.scope {
 // CHECK-NEXT:     cir.while {
 // CHECK-NEXT:       %3 = cir.const #cir.int<1> : !s32i
-// CHECK-NEXT:       %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
+// CHECK-NEXT:       %4 = cir.cast int_to_bool %3 : !s32i -> !cir.bool
 // CHECK-NEXT:       cir.condition(%4)
 // CHECK-NEXT:     } do {
 // CHECK-NEXT:       cir.scope {
@@ -151,7 +151,7 @@ void l3(bool cond) {
 // CHECK-NEXT:     cir.yield
 // CHECK-NEXT:   } while {
 // CHECK-NEXT:     %3 = cir.const #cir.int<1> : !s32i
-// CHECK-NEXT:     %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
+// CHECK-NEXT:     %4 = cir.cast int_to_bool %3 : !s32i -> !cir.bool
 // CHECK-NEXT:     cir.condition(%4)
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
@@ -196,7 +196,7 @@ void l5() {
 // CHECK-NEXT:       cir.yield
 // CHECK-NEXT:     } while {
 // CHECK-NEXT:       %0 = cir.const #cir.int<0> : !s32i
-// CHECK-NEXT:       %1 = cir.cast(int_to_bool, %0 : !s32i), !cir.bool
+// CHECK-NEXT:       %1 = cir.cast int_to_bool %0 : !s32i -> !cir.bool
 // CHECK-NEXT:       cir.condition(%1)
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
diff --git a/clang/test/CIR/CodeGen/new-null.cpp b/clang/test/CIR/CodeGen/new-null.cpp
index a8a7630b7270..133640155f5a 100644
--- a/clang/test/CIR/CodeGen/new-null.cpp
+++ b/clang/test/CIR/CodeGen/new-null.cpp
@@ -55,7 +55,7 @@ namespace test15 {
   // CIR:           %[[VAL_5:.*]] = cir.call @_ZnwmPvb(%[[VAL_2]], %[[VAL_3]], %[[VAL_4]])
   // CIR:           %[[VAL_6:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!void>
   // CIR:           %[[VAL_7:.*]] = cir.cmp(ne, %[[VAL_5]], %[[VAL_6]]) : !cir.ptr<!void>, !cir.bool
-  // CIR:           %[[VAL_8:.*]] = cir.cast(bitcast, %[[VAL_5]] : !cir.ptr<!void>), !cir.ptr<![[TEST15A]]>
+  // CIR:           %[[VAL_8:.*]] = cir.cast bitcast %[[VAL_5]] : !cir.ptr<!void> -> !cir.ptr<![[TEST15A]]>
   // CIR:           cir.if %[[VAL_7]] {
   // CIR:             cir.call @_ZN6test151AC1Ev(%[[VAL_8]]) : (!cir.ptr<![[TEST15A]]>) -> ()
   // CIR:           }
diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp
index 8ab7a8fbc12c..2d400e4326b3 100644
--- a/clang/test/CIR/CodeGen/new.cpp
+++ b/clang/test/CIR/CodeGen/new.cpp
@@ -20,7 +20,7 @@ void m(int a, int b) {
 // CHECK:   cir.scope {
 // 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:     %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>
@@ -44,8 +44,8 @@ class 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:   %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>
+// 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>
 
 // cir.call @B::B()(%new_placament_ptr)
 // CHECK:   cir.call @_ZN1BC1Ev(%6) : (!cir.ptr<!rec_B>) -> ()
@@ -70,7 +70,7 @@ void t_new_constant_size() {
 // CHECK:    %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<16> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<128> : !u64i
 // CHECK:    %3 = cir.call @_Znam(%[[ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %4 = cir.cast(bitcast, %3 : !cir.ptr<!void>), !cir.ptr<!cir.double>
+// CHECK:    %4 = cir.cast bitcast %3 : !cir.ptr<!void> -> !cir.ptr<!cir.double>
 // CHECK:    cir.store{{.*}} %4, %0 : !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>
 // CHECK:    cir.return
 // CHECK:  }
@@ -86,8 +86,8 @@ void t_new_multidim_constant_size() {
 // CHECK:    %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<24> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<192> : !u64i
 // CHECK:    %3 = cir.call @_Znam(%[[ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %4 = cir.cast(bitcast, %3 : !cir.ptr<!void>), !cir.ptr<!cir.double>
-// CHECK:    %5 = cir.cast(bitcast, %0 : !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>>), !cir.ptr<!cir.ptr<!cir.double>>
+// CHECK:    %4 = cir.cast bitcast %3 : !cir.ptr<!void> -> !cir.ptr<!cir.double>
+// CHECK:    %5 = cir.cast bitcast %0 : !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>> -> !cir.ptr<!cir.ptr<!cir.double>>
 // CHECK:    cir.store{{.*}} %4, %5 : !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>
 // CHECK:  }
 
@@ -106,12 +106,12 @@ void t_constant_size_nontrivial() {
 // CHECK:    %[[SIZE_WITHOUT_COOKIE:.*]] = cir.const #cir.int<3> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<11> : !u64i
 // CHECK:    %4 = cir.call @_Znam(%[[ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %5 = cir.cast(bitcast, %4 : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CHECK:    %5 = cir.cast bitcast %4 : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CHECK:    cir.store{{.*}} %[[NUM_ELEMENTS]], %5 : !u64i, !cir.ptr<!u64i>
-// CHECK:    %6 = cir.cast(bitcast, %4 : !cir.ptr<!void>), !cir.ptr<!u8i>
+// CHECK:    %6 = cir.cast bitcast %4 : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // CHECK:    %[[COOKIE_SIZE:.*]] = cir.const #cir.int<8> : !s32i
 // CHECK:    %8 = cir.ptr_stride %6, %[[COOKIE_SIZE]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
-// CHECK:    %9 = cir.cast(bitcast, %8 : !cir.ptr<!u8i>), !cir.ptr<!rec_C>
+// CHECK:    %9 = cir.cast bitcast %8 : !cir.ptr<!u8i> -> !cir.ptr<!rec_C>
 // CHECK:    cir.store{{.*}} %9, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
 // CHECK:    cir.return
 // CHECK:  }
@@ -135,12 +135,12 @@ void t_constant_size_nontrivial2() {
 // CHECK:    %[[SIZE_WITHOUT_COOKIE:.*]] = cir.const #cir.int<12> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<20> : !u64i
 // CHECK:    %4 = cir.call @_Znam(%[[ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %5 = cir.cast(bitcast, %4 : !cir.ptr<!void>), !cir.ptr<!u64i>
+// CHECK:    %5 = cir.cast bitcast %4 : !cir.ptr<!void> -> !cir.ptr<!u64i>
 // CHECK:    cir.store{{.*}} %[[NUM_ELEMENTS]], %5 : !u64i, !cir.ptr<!u64i>
-// CHECK:    %6 = cir.cast(bitcast, %4 : !cir.ptr<!void>), !cir.ptr<!u8i>
+// CHECK:    %6 = cir.cast bitcast %4 : !cir.ptr<!void> -> !cir.ptr<!u8i>
 // CHECK:    %[[COOKIE_SIZE:.*]] = cir.const #cir.int<8> : !s32i
 // CHECK:    %8 = cir.ptr_stride %6, %[[COOKIE_SIZE]] : (!cir.ptr<!u8i>, !s32i) -> !cir.ptr<!u8i>
-// CHECK:    %9 = cir.cast(bitcast, %8 : !cir.ptr<!u8i>), !cir.ptr<!rec_D>
+// CHECK:    %9 = cir.cast bitcast %8 : !cir.ptr<!u8i> -> !cir.ptr<!rec_D>
 // CHECK:    cir.store{{.*}} %9, %0 : !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>
 // CHECK:    cir.return
 // CHECK:  }
@@ -156,10 +156,10 @@ void t_constant_size_memset_init() {
 // CHECK:    %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<16> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<64> : !u64i
 // CHECK:    %[[ALLOC_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %[[ELEM_PTR:.*]] = cir.cast(bitcast, %[[ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!s32i>
-// CHECK:    %[[VOID_PTR:.*]] = cir.cast(bitcast, %[[ELEM_PTR]] : !cir.ptr<!s32i>), !cir.ptr<!void>
+// CHECK:    %[[ELEM_PTR:.*]] = cir.cast bitcast %[[ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
+// CHECK:    %[[VOID_PTR:.*]] = cir.cast bitcast %[[ELEM_PTR]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
 // CHECK:    %[[ZERO:.*]] = cir.const #cir.int<0> : !u8i
-// CHECK:    %[[ZERO_I32:.*]] = cir.cast(integral, %[[ZERO]] : !u8i), !s32i
+// CHECK:    %[[ZERO_I32:.*]] = cir.cast integral %[[ZERO]] : !u8i -> !s32i
 // CHECK:    cir.libc.memset %[[ALLOCATION_SIZE]] bytes from %[[VOID_PTR]] set to %[[ZERO_I32]] : !cir.ptr<!void>, !s32i, !u64i
 
 void t_constant_size_partial_init() {
@@ -170,7 +170,7 @@ void t_constant_size_partial_init() {
 // CHECK:    %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<16> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<64> : !u64i
 // CHECK:    %[[ALLOC_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %[[ELEM_0_PTR:.*]] = cir.cast(bitcast, %[[ALLOC_PTR]] : !cir.ptr<!void>), !cir.ptr<!s32i>
+// CHECK:    %[[ELEM_0_PTR:.*]] = cir.cast bitcast %[[ALLOC_PTR]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
 // CHECK:    %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !s32i
 // CHECK:    cir.store{{.*}} %[[CONST_ONE]], %[[ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
 // CHECK:    %[[OFFSET:.*]] = cir.const #cir.int<1> : !s32i
@@ -185,9 +185,9 @@ void t_constant_size_partial_init() {
 // CHECK:    %[[ELEM_3_PTR:.*]] = cir.ptr_stride %[[ELEM_2_PTR]], %[[OFFSET2]] : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
 // CHECK:    %[[INIT_SIZE:.*]] = cir.const #cir.int<12> : !u64i
 // CHECK:    %[[REMAINING_SIZE:.*]] = cir.binop(sub, %[[ALLOCATION_SIZE]], %[[INIT_SIZE]]) : !u64i
-// CHECK:    %[[VOID_PTR:.*]] = cir.cast(bitcast, %[[ELEM_3_PTR]] : !cir.ptr<!s32i>), !cir.ptr<!void>
+// CHECK:    %[[VOID_PTR:.*]] = cir.cast bitcast %[[ELEM_3_PTR]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
 // CHECK:    %[[ZERO:.*]] = cir.const #cir.int<0> : !u8i
-// CHECK:    %[[ZERO_I32:.*]] = cir.cast(integral, %[[ZERO]] : !u8i), !s32i
+// CHECK:    %[[ZERO_I32:.*]] = cir.cast integral %[[ZERO]] : !u8i -> !s32i
 // CHECK:    cir.libc.memset %[[REMAINING_SIZE]] bytes from %[[VOID_PTR]] set to %[[ZERO_I32]] : !cir.ptr<!void>, !s32i, !u64i
 
 void t_new_var_size(size_t n) {
@@ -204,7 +204,7 @@ void t_new_var_size2(int n) {
 
 // CHECK:  cir.func dso_local @_Z15t_new_var_size2i
 // CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
-// CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
+// CHECK:    %[[N_SIZE_T:.*]] = cir.cast integral %[[N]] : !s32i -> !u64i
 // CHECK:    %[[PTR:.*]] = cir.call @_Znam(%[[N_SIZE_T]]) : (!u64i)
 
 void t_new_var_size3(size_t n) {
@@ -225,7 +225,7 @@ void t_new_var_size4(int n) {
 
 // CHECK:  cir.func dso_local @_Z15t_new_var_size4i
 // CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
-// CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
+// 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)
 // CHECK:    %[[ALL_ONES:.*]] = cir.const #cir.int<18446744073709551615> : !u64i
@@ -240,7 +240,7 @@ void t_new_var_size5(int n) {
 
 // CHECK:  cir.func dso_local @_Z15t_new_var_size5i
 // CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
-// CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
+// 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)
 // CHECK:    %[[NUM_ELEMENTS_MULTIPLIER:.*]] = cir.const #cir.int<6>
@@ -255,7 +255,7 @@ void t_new_var_size6(int n) {
 
 // CHECK:  cir.func dso_local @_Z15t_new_var_size6i
 // CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
-// CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s32i), !u64i
+// 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
 // CHECK:    %[[ELEMENT_SIZE:.*]] = cir.const #cir.int<8> : !u64i
@@ -271,7 +271,7 @@ void t_new_var_size7(__int128 n) {
 
 // CHECK:  cir.func dso_local @_Z15t_new_var_size7n
 // CHECK:    %[[N:.*]] = cir.load{{.*}} %[[ARG_ALLOCA:.*]]
-// CHECK:    %[[N_SIZE_T:.*]] = cir.cast(integral, %[[N]] : !s128i), !u64i
+// 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)
 // CHECK:    %[[ALL_ONES:.*]] = cir.const #cir.int<18446744073709551615> : !u64i
@@ -301,8 +301,8 @@ void t_multidim_init() {
 // CHECK:    %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<6> : !u64i
 // CHECK:    %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<24> : !u64i
 // CHECK:    %[[NEW_PTR:.*]] = cir.call @_Znam(%2) : (!u64i) -> !cir.ptr<!void>
-// CHECK:    %[[ELEMENT_PTR:.*]] = cir.cast(bitcast, %[[NEW_PTR]] : !cir.ptr<!void>), !cir.ptr<!s32i>
-// CHECK:    %[[ARRAY_ELEM0_PTR:.*]] = cir.cast(bitcast, %[[ELEMENT_PTR]] : !cir.ptr<!s32i>), !cir.ptr<!cir.array<!s32i x 3>>
+// CHECK:    %[[ELEMENT_PTR:.*]] = cir.cast bitcast %[[NEW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
+// CHECK:    %[[ARRAY_ELEM0_PTR:.*]] = cir.cast bitcast %[[ELEMENT_PTR]] : !cir.ptr<!s32i> -> !cir.ptr<!cir.array<!s32i x 3>>
 // CHECK:    %[[OFFSET0:.*]] = cir.const #cir.int<0> : !s32i
 // CHECK:    %[[ELEM_00_PTR:.*]] = cir.get_element %[[ARRAY_ELEM0_PTR]][%[[OFFSET0]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s32i) -> !cir.ptr<!s32i>
 // CHECK:    %[[ELEM_00_VAL:.*]] = cir.const #cir.int<1> : !s32i
diff --git a/clang/test/CIR/CodeGen/no-proto-fun-ptr.c b/clang/test/CIR/CodeGen/no-proto-fun-ptr.c
index 0dcf79f68c0f..72504a599451 100644
--- a/clang/test/CIR/CodeGen/no-proto-fun-ptr.c
+++ b/clang/test/CIR/CodeGen/no-proto-fun-ptr.c
@@ -22,6 +22,6 @@ void buz() {
 // CHECK:  cir.func no_proto dso_local @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:    [[CAST:%.*]] = cir.cast(bitcast, %1 : !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/no-prototype.c b/clang/test/CIR/CodeGen/no-prototype.c
index 4be6a94c1212..728c4b80b95a 100644
--- a/clang/test/CIR/CodeGen/no-prototype.c
+++ b/clang/test/CIR/CodeGen/no-prototype.c
@@ -51,7 +51,7 @@ int test3(int x) {
 // CHECK: cir.func dso_local @test3
   return noProto3(x);
   // CHECK:  [[GGO:%.*]] = cir.get_global @noProto3 : !cir.ptr<!cir.func<(...) -> !s32i>>
-  // CHECK:  [[CAST:%.*]] = cir.cast(bitcast, [[GGO]] : !cir.ptr<!cir.func<(...) -> !s32i>>), !cir.ptr<!cir.func<(!s32i) -> !s32i>>
+  // CHECK:  [[CAST:%.*]] = cir.cast bitcast [[GGO]] : !cir.ptr<!cir.func<(...) -> !s32i>> -> !cir.ptr<!cir.func<(!s32i) -> !s32i>>
   // CHECK:  {{%.*}} = cir.call [[CAST]](%{{[0-9]+}}) : (!cir.ptr<!cir.func<(!s32i) -> !s32i>>, !s32i) -> !s32i
 }
 
@@ -68,7 +68,7 @@ int noProto4() { return 0; }
 int test4(int x) {
   return noProto4(x); // Even if we know the definition, this should compile.
   // CHECK:  [[GGO:%.*]] = cir.get_global @noProto4 : !cir.ptr<!cir.func<() -> !s32i>>
-  // CHECK:  [[CAST:%.*]] = cir.cast(bitcast, [[GGO]] : !cir.ptr<!cir.func<() -> !s32i>>), !cir.ptr<!cir.func<(!s32i) -> !s32i>>
+  // CHECK:  [[CAST:%.*]] = cir.cast bitcast [[GGO]] : !cir.ptr<!cir.func<() -> !s32i>> -> !cir.ptr<!cir.func<(!s32i) -> !s32i>>
   // CHECK:  {{%.*}} = cir.call [[CAST]]({{%.*}}) : (!cir.ptr<!cir.func<(!s32i) -> !s32i>>, !s32i) -> !s32i
 }
 
@@ -77,7 +77,7 @@ int noProto5();
 int test5(int x) {
   return noProto5();
   // CHECK:  [[GGO:%.*]] = cir.get_global @noProto5 : !cir.ptr<!cir.func<(!s32i) -> !s32i>>
-  // CHECK:  [[CAST:%.*]] = cir.cast(bitcast, [[GGO]] : !cir.ptr<!cir.func<(!s32i) -> !s32i>>), !cir.ptr<!cir.func<() -> !s32i>>
+  // CHECK:  [[CAST:%.*]] = cir.cast bitcast [[GGO]] : !cir.ptr<!cir.func<(!s32i) -> !s32i>> -> !cir.ptr<!cir.func<() -> !s32i>>
   // CHECK:  {{%.*}} = cir.call [[CAST]]() : (!cir.ptr<!cir.func<() -> !s32i>>) -> !s32i
 }
 int noProto5(int x) { return x; }
diff --git a/clang/test/CIR/CodeGen/nrvo.cpp b/clang/test/CIR/CodeGen/nrvo.cpp
index af9e178e2d13..1821c2953465 100644
--- a/clang/test/CIR/CodeGen/nrvo.cpp
+++ b/clang/test/CIR/CodeGen/nrvo.cpp
@@ -20,7 +20,7 @@ std::vector<const char*> test_nrvo() {
 // CHECK:   cir.scope {
 // CHECK:     %5 = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["ref.tmp0"] {alignment = 8 : i64}
 // CHECK:     %6 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 59>>
-// CHECK:     %7 = cir.cast(array_to_ptrdecay, %6 : !cir.ptr<!cir.array<!s8i x 59>>), !cir.ptr<!s8i>
+// CHECK:     %7 = cir.cast array_to_ptrdecay %6 : !cir.ptr<!cir.array<!s8i x 59>> -> !cir.ptr<!s8i>
 // CHECK:     cir.store{{.*}} %7, %5 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CHECK:     cir.call @_ZNSt6vectorIPKcE9push_backEOS1_(%0, %5) : (!cir.ptr<![[VEC]]>, !cir.ptr<!cir.ptr<!s8i>>) -> ()
 // CHECK:   }
diff --git a/clang/test/CIR/CodeGen/null-arithmatic-expression.c b/clang/test/CIR/CodeGen/null-arithmatic-expression.c
index a59a89e151f7..d3d45aed410e 100644
--- a/clang/test/CIR/CodeGen/null-arithmatic-expression.c
+++ b/clang/test/CIR/CodeGen/null-arithmatic-expression.c
@@ -8,5 +8,5 @@ char *foo() {
 
 // CHECK:  cir.func no_proto dso_local @foo()
 // CHECK:    [[CONST_1:%[0-9]+]] = cir.const #cir.int<1> : !s32i
-// CHECK:    {{.*}} = cir.cast(int_to_ptr, [[CONST_1]] : !s32i)
+// CHECK:    {{.*}} = cir.cast int_to_ptr [[CONST_1]] : !s32i
 // CHECK:    cir.return
diff --git a/clang/test/CIR/CodeGen/opaque.c b/clang/test/CIR/CodeGen/opaque.c
index e4dabafe51bd..04bff63d5c62 100644
--- a/clang/test/CIR/CodeGen/opaque.c
+++ b/clang/test/CIR/CodeGen/opaque.c
@@ -7,6 +7,6 @@ int foo(int x, short y) {
 
 // CHECK: cir.func dso_local @foo
 // CHECK: %[[Load:.*]] = cir.load
-// CHECK: %[[Bool:.*]] = cir.cast(int_to_bool, %[[Load]] : !s32i), !cir.bool loc(#loc8)
+// CHECK: %[[Bool:.*]] = cir.cast int_to_bool %[[Load]] : !s32i -> !cir.bool loc(#loc8)
 // CHECK: = cir.ternary(%[[Bool]], true {
 // CHECK:   cir.yield %[[Load]]
diff --git a/clang/test/CIR/CodeGen/opaque.cpp b/clang/test/CIR/CodeGen/opaque.cpp
index 4f5013896e24..613a95e92e79 100644
--- a/clang/test/CIR/CodeGen/opaque.cpp
+++ b/clang/test/CIR/CodeGen/opaque.cpp
@@ -35,8 +35,8 @@ void foo2() {
 // CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
 // CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
 // CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
-// CIR: %[[A_REAL_BOOL:.*]] = cir.cast(float_to_bool, %[[A_REAL]] : !cir.float), !cir.bool
-// CIR: %[[A_IMAG_BOOL:.*]] = cir.cast(float_to_bool, %[[A_IMAG]] : !cir.float), !cir.bool
+// CIR: %[[A_REAL_BOOL:.*]] = cir.cast float_to_bool %[[A_REAL]] : !cir.float -> !cir.bool
+// CIR: %[[A_IMAG_BOOL:.*]] = cir.cast float_to_bool %[[A_IMAG]] : !cir.float -> !cir.bool
 // CIR: %[[CONST_TRUE:.*]] = cir.const #true
 // CIR: %[[COND:.*]] = cir.select if %[[A_REAL_BOOL]] then %[[CONST_TRUE]] else %[[A_IMAG_BOOL]] : (!cir.bool, !cir.bool, !cir.bool) -> !cir.bool
 // CIR: %[[RESULT:.*]] = cir.ternary(%[[COND]], true {
@@ -109,7 +109,7 @@ void foo3() {
 // CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
 // CIR: %[[C_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
 // CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
-// CIR: %[[A_BOOL:.*]] = cir.cast(int_to_bool, %[[TMP_A]] : !s32i), !cir.bool
+// CIR: %[[A_BOOL:.*]] = cir.cast int_to_bool %[[TMP_A]] : !s32i -> !cir.bool
 // CIR: %[[RESULT:.*]] = cir.ternary(%[[A_BOOL]], true {
 // CIR:   %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
 // CIR:   cir.yield %[[TMP_A]] : !s32i
diff --git a/clang/test/CIR/CodeGen/pass-object-size.c b/clang/test/CIR/CodeGen/pass-object-size.c
index d0031555c202..a09b1693ddb6 100644
--- a/clang/test/CIR/CodeGen/pass-object-size.c
+++ b/clang/test/CIR/CodeGen/pass-object-size.c
@@ -14,10 +14,10 @@ void c() {
 
 // CIR: cir.func no_proto dso_local @c()
 // CIR: [[TMP0:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %{{[0-9]+}} : !u64i, ["vla"] {alignment = 16 : i64}
-// CIR: [[TMP1:%.*]] = cir.cast(bitcast, [[TMP0]] : !cir.ptr<!s32i>), !cir.ptr<!void>
+// CIR: [[TMP1:%.*]] = cir.cast bitcast [[TMP0]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
 // CIR-NEXT: [[TMP2:%.*]] = cir.objsize([[TMP1]] : <!void>, max) -> !u64i
 // CIR-NEXT: cir.call @b([[TMP1]], [[TMP2]]) : (!cir.ptr<!void>, !u64i) -> ()
-// CIR: [[TMP3:%.*]] = cir.cast(bitcast, [[TMP0]] : !cir.ptr<!s32i>), !cir.ptr<!void>
+// CIR: [[TMP3:%.*]] = cir.cast bitcast [[TMP0]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
 // CIR: [[TMP4:%.*]] = cir.objsize([[TMP3]] : <!void>, min) -> !u64i
 // CIR-NEXT: cir.call @e([[TMP3]], [[TMP4]]) : (!cir.ptr<!void>, !u64i) -> ()
 
diff --git a/clang/test/CIR/CodeGen/pointer-arith-ext.c b/clang/test/CIR/CodeGen/pointer-arith-ext.c
index a37a14c646b8..e3e604d0b5b9 100644
--- a/clang/test/CIR/CodeGen/pointer-arith-ext.c
+++ b/clang/test/CIR/CodeGen/pointer-arith-ext.c
@@ -25,7 +25,7 @@ void *f3(int a, void *b) { return a + b; }
 void *f3_1(int a, void *b) { return (a += b); }
 // CIR-LABEL: @f3_1
 // CIR: %[[NEW_PTR:.*]] = cir.ptr_stride
-// CIR: cir.cast(ptr_to_int, %[[NEW_PTR]] : !cir.ptr<!void>), !s32i
+// CIR: cir.cast ptr_to_int %[[NEW_PTR]] : !cir.ptr<!void> -> !s32i
 
 // LLVM-LABEL: @f3_1
 // LLVM: %[[NEW_PTR:.*]] = getelementptr
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 ca6dd66150f2..3c178159cb5d 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
@@ -85,7 +85,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-NEXT:   %{{.+}} = cir.cast(member_ptr_to_bool, %[[#x]] : !cir.data_member<!s32i in !rec_Foo>), !cir.bool
+// CIR-NEXT:   %{{.+}} = cir.cast member_ptr_to_bool %[[#x]] : !cir.data_member<!s32i in !rec_Foo> -> !cir.bool
 //      CIR: }
 
 auto bitcast(int Foo::*x) {
@@ -94,5 +94,5 @@ 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-NEXT:   %{{.+}} = cir.cast(bitcast, %[[#x]] : !cir.data_member<!s32i in !rec_Foo>), !cir.data_member<!s32i in !rec_Bar>
+// 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-member-func.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
index 458b850285a6..3515f91f2875 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
@@ -128,7 +128,7 @@ bool memfunc_to_bool(void (Foo::*func)(int)) {
 }
 
 // CIR-LABEL: @_Z15memfunc_to_boolM3FooFviE
-// CIR:   %{{.+}} = cir.cast(member_ptr_to_bool, %{{.+}} : !cir.method<!cir.func<(!s32i)> in !rec_Foo>), !cir.bool
+// CIR:   %{{.+}} = cir.cast member_ptr_to_bool %{{.+}} : !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.bool
 // CIR: }
 
 // LLVM-LABEL: @_Z15memfunc_to_boolM3FooFviE
@@ -142,7 +142,7 @@ auto memfunc_reinterpret(void (Foo::*func)(int)) -> void (Bar::*)() {
 }
 
 // CIR-LABEL: @_Z19memfunc_reinterpretM3FooFviE
-// CIR:   %{{.+}} = cir.cast(bitcast, %{{.+}} : !cir.method<!cir.func<(!s32i)> in !rec_Foo>), !cir.method<!cir.func<()> in !rec_Bar>
+// CIR:   %{{.+}} = cir.cast bitcast %{{.+}} : !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.method<!cir.func<()> in !rec_Bar>
 // CIR: }
 
 // LLVM-LABEL: @_Z19memfunc_reinterpretM3FooFviE
diff --git a/clang/test/CIR/CodeGen/pointers.cpp b/clang/test/CIR/CodeGen/pointers.cpp
index 4a17028f535c..82631fcfdf95 100644
--- a/clang/test/CIR/CodeGen/pointers.cpp
+++ b/clang/test/CIR/CodeGen/pointers.cpp
@@ -24,7 +24,7 @@ void foo(int *iptr, char *cptr, unsigned ustride) {
   // Must convert unsigned stride to a signed one.
   *(iptr - ustride) = 1;
   // CHECK: %[[#STRIDE:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!u32i>, !u32i
-  // CHECK: %[[#SIGNSTRIDE:]] = cir.cast(integral, %[[#STRIDE]] : !u32i), !s32i
+  // CHECK: %[[#SIGNSTRIDE:]] = cir.cast integral %[[#STRIDE]] : !u32i -> !s32i
   // CHECK: %[[#NEGSTRIDE:]] = cir.unary(minus, %[[#SIGNSTRIDE]]) : !s32i, !s32i
   // CHECK: cir.ptr_stride inbounds %{{.+}}, %[[#NEGSTRIDE]] : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
 }
diff --git a/clang/test/CIR/CodeGen/pred-info-builtins.c b/clang/test/CIR/CodeGen/pred-info-builtins.c
index ccc203764cef..024f7e0ac83d 100644
--- a/clang/test/CIR/CodeGen/pred-info-builtins.c
+++ b/clang/test/CIR/CodeGen/pred-info-builtins.c
@@ -13,7 +13,7 @@ void expect(int x) {
 
 // CIR-O2: cir.func dso_local @expect
 // CIR-O2:   [[EXPECT:%.*]] = cir.expect({{.*}}, {{.*}}) : !s64i
-// CIR-O2:   [[EXPECT_BOOL:%.*]] = cir.cast(int_to_bool, [[EXPECT]] : !s64i), !cir.bool
+// CIR-O2:   [[EXPECT_BOOL:%.*]] = cir.cast int_to_bool [[EXPECT]] : !s64i -> !cir.bool
 // CIR-O2:   cir.if [[EXPECT_BOOL]]
 // CIR-O2:     cir.call @bar() : () -> ()
 
@@ -27,7 +27,7 @@ void expect_with_probability(int x) {
 
 // CIR-O2:  cir.func dso_local @expect_with_probability
 // CIR-O2:    [[EXPECT:%.*]] = cir.expect({{.*}}, {{.*}}, 8.000000e-01) : !s64i
-// CIR-O2:    [[EXPECT_BOOL:%.*]] = cir.cast(int_to_bool, [[EXPECT]] : !s64i), !cir.bool
+// CIR-O2:    [[EXPECT_BOOL:%.*]] = cir.cast int_to_bool [[EXPECT]] : !s64i -> !cir.bool
 // CIR-O2:    cir.if [[EXPECT_BOOL]]
 // CIR-O2:      cir.call @bar() : () -> ()
 
diff --git a/clang/test/CIR/CodeGen/predefined.cpp b/clang/test/CIR/CodeGen/predefined.cpp
index f02e99aed3a5..48b7f29b08f5 100644
--- a/clang/test/CIR/CodeGen/predefined.cpp
+++ b/clang/test/CIR/CodeGen/predefined.cpp
@@ -11,12 +11,12 @@ void m() {
 
 // CHECK: cir.func dso_local @_Z1mv()
 // CHECK:     %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 7>>
-// CHECK:     %1 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s8i x 7>>), !cir.ptr<!s8i>
+// CHECK:     %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 7>> -> !cir.ptr<!s8i>
 // CHECK:     %2 = cir.const #cir.int<79> : !s32i
 // CHECK:     %3 = cir.get_global @".str.1" : !cir.ptr<!cir.array<!s8i x 9>>
-// CHECK:     %4 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!s8i x 9>>), !cir.ptr<!s8i>
+// CHECK:     %4 = cir.cast array_to_ptrdecay %3 : !cir.ptr<!cir.array<!s8i x 9>> -> !cir.ptr<!s8i>
 // CHECK:     %5 = cir.get_global @".str.2" : !cir.ptr<!cir.array<!s8i x 5>>
-// CHECK:     %6 = cir.cast(array_to_ptrdecay, %5 : !cir.ptr<!cir.array<!s8i x 5>>), !cir.ptr<!s8i>
+// CHECK:     %6 = cir.cast array_to_ptrdecay %5 : !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!s8i>
 // CHECK:     cir.call @__assert2(%1, %2, %4, %6) : (!cir.ptr<!s8i>, !s32i, !cir.ptr<!s8i>, !cir.ptr<!s8i>) -> ()
 // CHECK:     cir.return
 // CHECK:   }
diff --git a/clang/test/CIR/CodeGen/ptrdiff.c b/clang/test/CIR/CodeGen/ptrdiff.c
index 1a937d5f4272..2045fee1a70a 100644
--- a/clang/test/CIR/CodeGen/ptrdiff.c
+++ b/clang/test/CIR/CodeGen/ptrdiff.c
@@ -6,7 +6,7 @@
 int addrcmp(const void* a, const void* b) {
   // CIR-LABEL: addrcmp
   // CIR: %[[R:.*]] = cir.ptr_diff
-  // CIR: cir.cast(integral,  %[[R]] : !s64i), !s32
+  // CIR: cir.cast integral  %[[R]] : !s64i -> !s32
 
   // LLVM-LABEL: addrcmp
   // LLVM: %[[PTR_A:.*]] = ptrtoint ptr {{.*}} to i64
diff --git a/clang/test/CIR/CodeGen/ptrdiff.cpp b/clang/test/CIR/CodeGen/ptrdiff.cpp
index bb058c822323..7397d4d80ed4 100644
--- a/clang/test/CIR/CodeGen/ptrdiff.cpp
+++ b/clang/test/CIR/CodeGen/ptrdiff.cpp
@@ -10,7 +10,7 @@ size_type size(unsigned long *_start, unsigned long *_finish) {
 // 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
+// CHECK:   %6 = cir.cast integral %5 : !s64i -> !u64i
 
 long add(char *a, char *b) {
   return a - b + 1;
@@ -19,5 +19,5 @@ long add(char *a, char *b) {
 // CHECK: cir.func dso_local @_Z3addPcS_(%arg0: !cir.ptr<!s8i>
 //          %5 = cir.ptr_diff(%3, %4) : !cir.ptr<!s8i> -> !s64i
 //          %6 = cir.const #cir.int<1> : !s32i
-//          %7 = cir.cast(integral, %6 : !s32i), !s64i
+//          %7 = cir.cast integral %6 : !s32i -> !s64i
 //          %8 = cir.binop(add, %5, %7) : !s64i
diff --git a/clang/test/CIR/CodeGen/rangefor.cpp b/clang/test/CIR/CodeGen/rangefor.cpp
index 4875bd798455..fb74daa186f7 100644
--- a/clang/test/CIR/CodeGen/rangefor.cpp
+++ b/clang/test/CIR/CodeGen/rangefor.cpp
@@ -30,7 +30,7 @@ void init(unsigned numImages) {
 // 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:   %3 = cir.cast(integral, %2 : !u32i), !u64i
+// CHECK:   %3 = cir.cast integral %2 : !u32i -> !u64i
 // CHECK:   cir.call @_ZNSt6vectorI6tripleEC1Em(%1, %3) : (!cir.ptr<![[VEC]]>, !u64i) -> ()
 // CHECK:   cir.scope {
 // CHECK:     %4 = cir.alloca !cir.ptr<![[VEC]]>, !cir.ptr<!cir.ptr<![[VEC]]>>, ["__range1", init, const] {alignment = 8 : i64}
diff --git a/clang/test/CIR/CodeGen/static.cpp b/clang/test/CIR/CodeGen/static.cpp
index b0d6c6264c1e..60adc39c703e 100644
--- a/clang/test/CIR/CodeGen/static.cpp
+++ b/clang/test/CIR/CodeGen/static.cpp
@@ -50,8 +50,8 @@ static Init __ioinit2(false);
 // AFTER-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!rec_Init>, !cir.bool) -> ()
 // AFTER-NEXT:     %2 = cir.get_global @_ZL8__ioinit : !cir.ptr<!rec_Init>
 // AFTER-NEXT:     %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr<!cir.func<(!cir.ptr<!rec_Init>)>>
-// AFTER-NEXT:     %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<(!cir.ptr<!rec_Init>)>>), !cir.ptr<!cir.func<(!cir.ptr<!void>)>>
-// AFTER-NEXT:     %5 = cir.cast(bitcast, %2 : !cir.ptr<!rec_Init>), !cir.ptr<!void>
+// AFTER-NEXT:     %4 = cir.cast bitcast %3 : !cir.ptr<!cir.func<(!cir.ptr<!rec_Init>)>> -> !cir.ptr<!cir.func<(!cir.ptr<!void>)>>
+// AFTER-NEXT:     %5 = cir.cast bitcast %2 : !cir.ptr<!rec_Init> -> !cir.ptr<!void>
 // AFTER-NEXT:     %6 = cir.get_global @__dso_handle : !cir.ptr<i8>
 // AFTER-NEXT:     cir.call @__cxa_atexit(%4, %5, %6) : (!cir.ptr<!cir.func<(!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>) -> ()
 // AFTER-NEXT:     cir.return
@@ -62,8 +62,8 @@ static Init __ioinit2(false);
 // AFTER-NEXT:     cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr<!rec_Init>, !cir.bool) -> ()
 // AFTER-NEXT:     %2 = cir.get_global @_ZL9__ioinit2 : !cir.ptr<!rec_Init>
 // AFTER-NEXT:     %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr<!cir.func<(!cir.ptr<!rec_Init>)>>
-// AFTER-NEXT:     %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<(!cir.ptr<!rec_Init>)>>), !cir.ptr<!cir.func<(!cir.ptr<!void>)>>
-// AFTER-NEXT:     %5 = cir.cast(bitcast, %2 : !cir.ptr<!rec_Init>), !cir.ptr<!void>
+// AFTER-NEXT:     %4 = cir.cast bitcast %3 : !cir.ptr<!cir.func<(!cir.ptr<!rec_Init>)>> -> !cir.ptr<!cir.func<(!cir.ptr<!void>)>>
+// AFTER-NEXT:     %5 = cir.cast bitcast %2 : !cir.ptr<!rec_Init> -> !cir.ptr<!void>
 // AFTER-NEXT:     %6 = cir.get_global @__dso_handle : !cir.ptr<i8>
 // AFTER-NEXT:     cir.call @__cxa_atexit(%4, %5, %6) : (!cir.ptr<!cir.func<(!cir.ptr<!void>)>>, !cir.ptr<!void>, !cir.ptr<i8>) -> ()
 // AFTER-NEXT:     cir.return
diff --git a/clang/test/CIR/CodeGen/stmtexpr-init.c b/clang/test/CIR/CodeGen/stmtexpr-init.c
index ede776daadd6..0e91ce5e79b6 100644
--- a/clang/test/CIR/CodeGen/stmtexpr-init.c
+++ b/clang/test/CIR/CodeGen/stmtexpr-init.c
@@ -42,7 +42,7 @@ void T2(void) {
   struct outer X = {ARRAY_PTR(10, 20, 30)};
 
   // CIR-DAG: %[[T2A:.*]] = cir.get_global @T2._a : !cir.ptr<![[annon_struct]]>
-  // CIR-DAG: cir.cast(bitcast, %[[T2A]] : !cir.ptr<![[annon_struct]]>), !cir.ptr<![[sized_array]]>
+  // CIR-DAG: cir.cast bitcast %[[T2A]] : !cir.ptr<![[annon_struct]]> -> !cir.ptr<![[sized_array]]>
   escape(A);
   escape(&X);
 }
diff --git a/clang/test/CIR/CodeGen/store.c b/clang/test/CIR/CodeGen/store.c
index 7bf64773396f..615a285cdf65 100644
--- a/clang/test/CIR/CodeGen/store.c
+++ b/clang/test/CIR/CodeGen/store.c
@@ -25,5 +25,5 @@ void storeNoArgsFn() {
 // CHECK:  cir.func {{.*@storeNoArgsFn}}
 // CHECK:    %0 = cir.alloca
 // CHECK:    %1 = cir.get_global @get42 : !cir.ptr<!cir.func<() -> !s32i>>
-// CHECK:    %2 = cir.cast(bitcast, %1 : !cir.ptr<!cir.func<() -> !s32i>>), !cir.ptr<!cir.func<(...) -> !s32i>>
+// CHECK:    %2 = cir.cast bitcast %1 : !cir.ptr<!cir.func<() -> !s32i>> -> !cir.ptr<!cir.func<(...) -> !s32i>>
 // CHECK:    cir.store{{.*}} %2, %0 : !cir.ptr<!cir.func<(...) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(...) -> !s32i>>>
diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c
index ca13ffe0a390..b01076e122e0 100644
--- a/clang/test/CIR/CodeGen/struct.c
+++ b/clang/test/CIR/CodeGen/struct.c
@@ -38,7 +38,7 @@ void shouldConstInitStructs(void) {
 // CHECK: cir.func dso_local @shouldConstInitStructs
   struct Foo f = {1, 2, {3, 4}};
   // CHECK: %[[#V0:]] = cir.alloca !rec_Foo, !cir.ptr<!rec_Foo>, ["f"] {alignment = 4 : i64}
-  // CHECK: %[[#V1:]] = cir.cast(bitcast, %[[#V0]] : !cir.ptr<!rec_Foo>), !cir.ptr<!rec_anon_struct1>
+  // CHECK: %[[#V1:]] = cir.cast bitcast %[[#V0]] : !cir.ptr<!rec_Foo> -> !cir.ptr<!rec_anon_struct1>
   // CHECK: %[[#V2:]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<2> : !s8i,
   // CHECK-SAME:        #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 3>,
   // CHECK-SAME:        #cir.const_record<{#cir.int<3> : !s32i, #cir.int<4> : !s8i,
diff --git a/clang/test/CIR/CodeGen/tbaa-enum.c b/clang/test/CIR/CodeGen/tbaa-enum.c
index e2315451d4a2..f55a381cebd8 100644
--- a/clang/test/CIR/CodeGen/tbaa-enum.c
+++ b/clang/test/CIR/CodeGen/tbaa-enum.c
@@ -48,11 +48,11 @@ typedef enum : uint8_t {
 uint32_t g0(EnumAuto32 *E, uint32_t *val) {
   // CIR-LABEL: cir.func dso_local @g0
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u32i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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: %[[U_C0:.*]] = cir.cast integral %[[C0]] : !s32i -> !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>
@@ -71,7 +71,7 @@ uint32_t g0(EnumAuto32 *E, uint32_t *val) {
 uint64_t g1(EnumAuto64 *E, uint64_t *val) {
   // CIR-LABEL: cir.func dso_local @g1
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u64i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
@@ -93,7 +93,7 @@ uint64_t g1(EnumAuto64 *E, uint64_t *val) {
 uint16_t g2(Enum16 *E, uint16_t *val) {
   // CIR-LABEL: cir.func dso_local @g2
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u16i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
@@ -115,7 +115,7 @@ uint16_t g2(Enum16 *E, uint16_t *val) {
 uint8_t g3(Enum8 *E, uint8_t *val) {
   // CIR-LABEL: cir.func dso_local @g3
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u8i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
diff --git a/clang/test/CIR/CodeGen/tbaa-enum.cpp b/clang/test/CIR/CodeGen/tbaa-enum.cpp
index c6fe2f99bb58..08f8201f434f 100644
--- a/clang/test/CIR/CodeGen/tbaa-enum.cpp
+++ b/clang/test/CIR/CodeGen/tbaa-enum.cpp
@@ -52,7 +52,7 @@ typedef enum : uint8_t {
 uint32_t g0(EnumAuto32 *E, uint32_t *val) {
   // CIR-LABEL: cir.func dso_local @_Z2g0
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u32i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
@@ -74,7 +74,7 @@ uint32_t g0(EnumAuto32 *E, uint32_t *val) {
 uint64_t g1(EnumAuto64 *E, uint64_t *val) {
   // CIR-LABEL: cir.func dso_local @_Z2g1
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u64i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
@@ -96,7 +96,7 @@ uint64_t g1(EnumAuto64 *E, uint64_t *val) {
 uint16_t g2(Enum16 *E, uint16_t *val) {
   // CIR-LABEL: cir.func dso_local @_Z2g2
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u16i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
@@ -118,7 +118,7 @@ uint16_t g2(Enum16 *E, uint16_t *val) {
 uint8_t g3(Enum8 *E, uint8_t *val) {
   // CIR-LABEL: cir.func dso_local @_Z2g3
   // CIR: %[[C5:.*]] = cir.const #cir.int<5> : !s32i
-  // CIR: %[[U_C5:.*]] = cir.cast(integral, %[[C5]] : !s32i), !u8i
+  // CIR: %[[U_C5:.*]] = cir.cast integral %[[C5]] : !s32i -> !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
diff --git a/clang/test/CIR/CodeGen/tbaa-scalar.c b/clang/test/CIR/CodeGen/tbaa-scalar.c
index 1ee9623010e4..21b733c0eed9 100644
--- a/clang/test/CIR/CodeGen/tbaa-scalar.c
+++ b/clang/test/CIR/CodeGen/tbaa-scalar.c
@@ -104,12 +104,12 @@ void test_char(char *a, char* b) {
   // 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: %[[C2_CHAR:.*]] = cir.cast integral %[[C2]] : !s32i -> !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: %[[C3_CHAR:.*]] = cir.cast integral %[[C3]] : !s32i -> !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 455076698899..065e3cab316c 100644
--- a/clang/test/CIR/CodeGen/tbaa-struct.cpp
+++ b/clang/test/CIR/CodeGen/tbaa-struct.cpp
@@ -84,10 +84,10 @@ typedef struct
 uint32_t g(uint32_t *s, StructA *A, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z1g
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[INT]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
 
 
@@ -105,10 +105,10 @@ uint32_t g(uint32_t *s, StructA *A, uint64_t count) {
 uint32_t g2(uint32_t *s, StructA *A, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g2
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[INT]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u16i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u16i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[TAG_StructA_f16]])
 
   // CHECK-LABEL: define{{.*}} i32 @_Z2g2
@@ -125,10 +125,10 @@ uint32_t g2(uint32_t *s, StructA *A, uint64_t count) {
 uint32_t g3(StructA *A, StructB *B, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g3
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructB_a_f32]])
 
   // CHECK-LABEL: define{{.*}} i32 @_Z2g3
@@ -145,10 +145,10 @@ uint32_t g3(StructA *A, StructB *B, uint64_t count) {
 uint32_t g4(StructA *A, StructB *B, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g4
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u16i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u16i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[TAG_StructB_a_f16]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g4
@@ -165,10 +165,10 @@ uint32_t g4(StructA *A, StructB *B, uint64_t count) {
 uint32_t g5(StructA *A, StructB *B, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g5
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructB_f32]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g5
@@ -185,10 +185,10 @@ uint32_t g5(StructA *A, StructB *B, uint64_t count) {
 uint32_t g6(StructA *A, StructB *B, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g6
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructB_a_f32_2]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g6
@@ -205,10 +205,10 @@ uint32_t g6(StructA *A, StructB *B, uint64_t count) {
 uint32_t g7(StructA *A, StructS *S, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g7
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructS_f32]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g7
@@ -225,10 +225,10 @@ uint32_t g7(StructA *A, StructS *S, uint64_t count) {
 uint32_t g8(StructA *A, StructS *S, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g8
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructA_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u16i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u16i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[TAG_StructS_f16]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g8
@@ -245,10 +245,10 @@ uint32_t g8(StructA *A, StructS *S, uint64_t count) {
 uint32_t g9(StructS *S, StructS2 *S2, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z2g9
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructS_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructS2_f32]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z2g9
@@ -265,10 +265,10 @@ uint32_t g9(StructS *S, StructS2 *S2, uint64_t count) {
 uint32_t g10(StructS *S, StructS2 *S2, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z3g10
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructS_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u16i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u16i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u16i, !cir.ptr<!u16i> tbaa(#tbaa[[TAG_StructS2_f16]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z3g10
@@ -285,10 +285,10 @@ uint32_t g10(StructS *S, StructS2 *S2, uint64_t count) {
 uint32_t g11(StructC *C, StructD *D, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z3g11
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructC_b_a_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructD_b_a_f32]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z3g11
@@ -305,10 +305,10 @@ uint32_t g11(StructC *C, StructD *D, uint64_t count) {
 uint32_t g12(StructC *C, StructD *D, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z3g12
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructB_a_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructB_a_f32]])
 
   // LLVM-LABEL: define{{.*}} i32 @_Z3g12
@@ -350,10 +350,10 @@ typedef StructS StructS3;
 uint32_t g15(StructS *S, StructS3 *S3, uint64_t count) {
   // CIR-LABEL: cir.func dso_local @_Z3g15
   // CIR: %[[INT_1:.*]] = cir.const #cir.int<1> : !s32i
-  // CIR: %[[UINT_1:.*]] = cir.cast(integral, %[[INT_1]] : !s32i), !u32i
+  // CIR: %[[UINT_1:.*]] = cir.cast integral %[[INT_1]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_1]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructS_f32]])
   // CIR: %[[INT_4:.*]] = cir.const #cir.int<4> : !s32i
-  // CIR: %[[UINT_4:.*]] = cir.cast(integral, %[[INT_4]] : !s32i), !u32i
+  // CIR: %[[UINT_4:.*]] = cir.cast integral %[[INT_4]] : !s32i -> !u32i
   // CIR: cir.store{{.*}} %[[UINT_4]], %{{.*}} : !u32i, !cir.ptr<!u32i> tbaa(#tbaa[[TAG_StructS_f32]])
 
 
diff --git a/clang/test/CIR/CodeGen/ternary.cpp b/clang/test/CIR/CodeGen/ternary.cpp
index 9a0f1e573f19..92c2996cdb4b 100644
--- a/clang/test/CIR/CodeGen/ternary.cpp
+++ b/clang/test/CIR/CodeGen/ternary.cpp
@@ -35,16 +35,16 @@ void m(APIType api) {
 // 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:    %2 = cir.cast(integral, %1 : !u32i), !s32i
+// CHECK:    %2 = cir.cast integral %1 : !u32i -> !s32i
 // CHECK:    %3 = cir.const #cir.int<0> : !u32i
-// CHECK:    %4 = cir.cast(integral, %3 : !u32i), !s32i
+// CHECK:    %4 = cir.cast integral %3 : !u32i -> !s32i
 // CHECK:    %5 = cir.cmp(eq, %2, %4) : !s32i, !cir.bool
 // CHECK:    cir.ternary(%5, true {
 // CHECK:      %6 = cir.const #cir.int<0> : !s32i
 // CHECK:      cir.yield
 // CHECK:    }, false {
 // CHECK:      %6 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 7>>
-// CHECK:      %7 = cir.cast(array_to_ptrdecay, %6 : !cir.ptr<!cir.array<!s8i x 7>>), !cir.ptr<!s8i>
+// CHECK:      %7 = cir.cast array_to_ptrdecay %6 : !cir.ptr<!cir.array<!s8i x 7>> -> !cir.ptr<!s8i>
 // CHECK:      cir.call @_Z3obaPKc(%7) : (!cir.ptr<!s8i>) -> ()
 // CHECK:      cir.yield
 // CHECK:    }) : (!cir.bool) -> ()
@@ -68,7 +68,7 @@ int foo(int a, int b) {
 // 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
+// CHECK:   [[RES_CAST:%.*]] = cir.cast int_to_bool [[RES]] : !s32i -> !cir.bool
 // CHECK:   cir.if [[RES_CAST]]
 
 void maybe_has_side_effects();
diff --git a/clang/test/CIR/CodeGen/throw.cpp b/clang/test/CIR/CodeGen/throw.cpp
index 7359f4c94aa8..ed42933bacbe 100644
--- a/clang/test/CIR/CodeGen/throw.cpp
+++ b/clang/test/CIR/CodeGen/throw.cpp
@@ -12,7 +12,7 @@ double d(int a, int b) {
 //      CIR: cir.if
 // CIR-NEXT:   %[[ADDR:.*]] = cir.alloc.exception 8
 // CIR-NEXT:   %[[STR:.*]] = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 28>>
-// CIR-NEXT:   %[[STR_ADD:.*]] = cir.cast(array_to_ptrdecay, %[[STR]] : !cir.ptr<!cir.array<!s8i x 28>>), !cir.ptr<!s8i>
+// CIR-NEXT:   %[[STR_ADD:.*]] = cir.cast array_to_ptrdecay %[[STR]] : !cir.ptr<!cir.array<!s8i x 28>> -> !cir.ptr<!s8i>
 // CIR-NEXT:   cir.store{{.*}} %[[STR_ADD]], %[[ADDR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CIR-NEXT:   cir.throw %[[ADDR]] : !cir.ptr<!cir.ptr<!s8i>>, @_ZTIPKc
 // CIR-NEXT:   cir.unreachable
diff --git a/clang/test/CIR/CodeGen/unary.c b/clang/test/CIR/CodeGen/unary.c
index ebcae89e2bdb..2fd0faad8530 100644
--- a/clang/test/CIR/CodeGen/unary.c
+++ b/clang/test/CIR/CodeGen/unary.c
@@ -5,7 +5,7 @@ int valueNegationInt(int i) {
 // CHECK: cir.func dso_local @valueNegationInt(
   return !i;
   // CHECK: %[[#INT:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s32i>, !s32i
-  // CHECK: %[[#INT_TO_BOOL:]] = cir.cast(int_to_bool, %[[#INT]] : !s32i), !cir.bool
+  // CHECK: %[[#INT_TO_BOOL:]] = cir.cast int_to_bool %[[#INT]] : !s32i -> !cir.bool
   // CHECK: = cir.unary(not, %[[#INT_TO_BOOL]]) : !cir.bool, !cir.bool
 }
 
@@ -13,7 +13,7 @@ short valueNegationShort(short s) {
 // CHECK: cir.func dso_local @valueNegationShort(
   return !s;
   // CHECK: %[[#SHORT:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s16i>, !s16i
-  // CHECK: %[[#SHORT_TO_BOOL:]] = cir.cast(int_to_bool, %[[#SHORT]] : !s16i), !cir.bool
+  // CHECK: %[[#SHORT_TO_BOOL:]] = cir.cast int_to_bool %[[#SHORT]] : !s16i -> !cir.bool
   // CHECK: = cir.unary(not, %[[#SHORT_TO_BOOL]]) : !cir.bool, !cir.bool
 }
 
@@ -21,7 +21,7 @@ long valueNegationLong(long l) {
 // CHECK: cir.func dso_local @valueNegationLong(
   return !l;
   // CHECK: %[[#LONG:]] = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
-  // CHECK: %[[#LONG_TO_BOOL:]] = cir.cast(int_to_bool, %[[#LONG]] : !s64i), !cir.bool
+  // CHECK: %[[#LONG_TO_BOOL:]] = cir.cast int_to_bool %[[#LONG]] : !s64i -> !cir.bool
   // CHECK: = cir.unary(not, %[[#LONG_TO_BOOL]]) : !cir.bool, !cir.bool
 }
 
@@ -29,16 +29,16 @@ float valueNegationFloat(float f) {
 // CHECK: cir.func dso_local @valueNegationFloat(
   return !f;
   // 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_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
+  // CHECK: = cir.cast bool_to_int %[[#FLOAT_NOT]] : !cir.bool -> !s32i
 }
 
 double valueNegationDouble(double d) {
 // CHECK: cir.func dso_local @valueNegationDouble(
   return !d;
   // 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_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
+  // 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 daeb01ec20e5..1053a53dc96b 100644
--- a/clang/test/CIR/CodeGen/unary.cpp
+++ b/clang/test/CIR/CodeGen/unary.cpp
@@ -163,7 +163,7 @@ void floats(float f) {
   f--; // CHECK: = cir.unary(dec, %{{[0-9]+}}) : !cir.float, !cir.float
 
   f = !f;
-  // CHECK: %[[#F_BOOL:]] = cir.cast(float_to_bool, %{{[0-9]+}} : !cir.float), !cir.bool
+  // CHECK: %[[#F_BOOL:]] = cir.cast float_to_bool %{{[0-9]+}} : !cir.float -> !cir.bool
   // CHECK: = cir.unary(not, %[[#F_BOOL]]) : !cir.bool, !cir.bool
 }
 
@@ -177,7 +177,7 @@ void doubles(double d) {
   d--; // CHECK: = cir.unary(dec, %{{[0-9]+}}) : !cir.double, !cir.double
 
   d = !d;
-  // CHECK: %[[#D_BOOL:]] = cir.cast(float_to_bool, %{{[0-9]+}} : !cir.double), !cir.bool
+  // CHECK: %[[#D_BOOL:]] = cir.cast float_to_bool %{{[0-9]+}} : !cir.double -> !cir.bool
   // CHECK: = cir.unary(not, %[[#D_BOOL]]) : !cir.bool, !cir.bool
 }
 
@@ -206,7 +206,7 @@ void pointers(int *p) {
   // CHECK:  cir.store{{.*}} %[[#RES]], %[[#P]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 
   bool p1 = !p;
-  // %[[BOOLPTR:]] = cir.cast(ptr_to_bool, %15 : !cir.ptr<!s32i>), !cir.bool
+  // %[[BOOLPTR:]] = cir.cast ptr_to_bool %15 : !cir.ptr<!s32i> -> !cir.bool
   // cir.unary(not, %[[BOOLPTR]]) : !cir.bool, !cir.bool
 }
 
@@ -214,10 +214,10 @@ void chars(char c) {
 // CHECK: cir.func dso_local @{{.+}}chars{{.+}}
 
   int c1 = +c;
-  // CHECK: %[[#PROMO:]] = cir.cast(integral, %{{.+}} : !s8i), !s32i
+  // CHECK: %[[#PROMO:]] = cir.cast integral %{{.+}} : !s8i -> !s32i
   // CHECK: cir.unary(plus, %[[#PROMO]]) : !s32i, !s32i
   int c2 = -c;
-  // CHECK: %[[#PROMO:]] = cir.cast(integral, %{{.+}} : !s8i), !s32i
+  // CHECK: %[[#PROMO:]] = cir.cast integral %{{.+}} : !s8i -> !s32i
   // CHECK: cir.unary(minus, %[[#PROMO]]) nsw : !s32i, !s32i
 
   // Chars can go through some integer promotion codegen paths even when not promoted.
@@ -227,6 +227,6 @@ void chars(char c) {
   c--; // CHECK: cir.unary(dec, %16) : !s8i, !s8i
 
   bool c3 = !c;
-  // CHECK: %[[#C_BOOL:]] = cir.cast(int_to_bool, %{{[0-9]+}} : !s8i), !cir.bool
+  // CHECK: %[[#C_BOOL:]] = cir.cast int_to_bool %{{[0-9]+}} : !s8i -> !cir.bool
   // CHECK: cir.unary(not, %[[#C_BOOL]]) : !cir.bool, !cir.bool
 }
diff --git a/clang/test/CIR/CodeGen/union-init.c b/clang/test/CIR/CodeGen/union-init.c
index 1fba83537752..0e2d8fbc51b5 100644
--- a/clang/test/CIR/CodeGen/union-init.c
+++ b/clang/test/CIR/CodeGen/union-init.c
@@ -44,7 +44,7 @@ unsigned is_little(void) {
 
 // CHECK: cir.func dso_local @is_little
 // CHECK: %[[VAL_1:.*]] = cir.get_global @is_little.one : !cir.ptr<![[anon0]]>
-// CHECK: %[[VAL_2:.*]] = cir.cast(bitcast, %[[VAL_1]] : !cir.ptr<![[anon0]]>), !cir.ptr<![[anon1]]>
+// CHECK: %[[VAL_2:.*]] = cir.cast bitcast %[[VAL_1]] : !cir.ptr<![[anon0]]> -> !cir.ptr<![[anon1]]>
 // CHECK: %[[VAL_3:.*]] = cir.get_member %[[VAL_2]][1] {name = "c"} : !cir.ptr<![[anon1]]> -> !cir.ptr<!cir.array<!u8i x 4>>
 
 typedef union {
@@ -54,7 +54,7 @@ typedef union {
 // CHECK: %[[VAL_0:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
 // 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_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: cir.store{{.*}} %[[VAL_3]], %[[VAL_2]] : !s32i, !cir.ptr<!s32i>
 
diff --git a/clang/test/CIR/CodeGen/union.cpp b/clang/test/CIR/CodeGen/union.cpp
index 96fe3e4be852..e94e78a959ff 100644
--- a/clang/test/CIR/CodeGen/union.cpp
+++ b/clang/test/CIR/CodeGen/union.cpp
@@ -85,7 +85,7 @@ typedef union {
 void noCrushOnDifferentSizes() {
   A a = {0};
   // CHECK:  %[[#TMP0:]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["a"] {alignment = 4 : i64}
-  // CHECK:  %[[#TMP1:]] = cir.cast(bitcast, %[[#TMP0]] : !cir.ptr<!rec_A>), !cir.ptr<!rec_anon_struct>
+  // CHECK:  %[[#TMP1:]] = cir.cast bitcast %[[#TMP0]] : !cir.ptr<!rec_A> -> !cir.ptr<!rec_anon_struct>
   // CHECK:  %[[#TMP2:]] = cir.const #cir.zero : !rec_anon_struct
   // CHECK:  cir.store{{.*}} %[[#TMP2]], %[[#TMP1]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
 }
diff --git a/clang/test/CIR/CodeGen/var-arg-float.c b/clang/test/CIR/CodeGen/var-arg-float.c
index 158a452e13a8..e5cad0a0a72f 100644
--- a/clang/test/CIR/CodeGen/var-arg-float.c
+++ b/clang/test/CIR/CodeGen/var-arg-float.c
@@ -49,9 +49,9 @@ 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: [[TMP2:%.*]] = cir.cast(bitcast, [[VR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
+// AFTER-NEXT: [[TMP2:%.*]] = cir.cast bitcast [[VR_TOP]] : !cir.ptr<!void> -> !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride [[TMP2]], [[VR_OFFS]] : (!cir.ptr<i8>, !s32i) -> !cir.ptr<i8>
-// AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast(bitcast, [[TMP3]] : !cir.ptr<i8>), !cir.ptr<!void>
+// AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast bitcast [[TMP3]] : !cir.ptr<i8> -> !cir.ptr<!void>
 // AFTER-NEXT: cir.br [[BB_END:\^bb.*]]([[IN_REG_OUTPUT]] : !cir.ptr<!void>)
 
 
@@ -59,14 +59,14 @@ double f1(int n, ...) {
 // 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: [[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: [[TMP4:%.*]] = cir.cast bitcast [[STACK_V]] : !cir.ptr<!void> -> !cir.ptr<i8>
 // AFTER-NEXT: [[TMP5:%.*]] = cir.ptr_stride [[TMP4]], [[EIGHT_IN_PTR_ARITH]] : (!cir.ptr<i8>, !u64i) -> !cir.ptr<i8>
-// AFTER-NEXT: [[NEW_STACK_V:%.*]] = cir.cast(bitcast, [[TMP5]] : !cir.ptr<i8>), !cir.ptr<!void>
+// AFTER-NEXT: [[NEW_STACK_V:%.*]] = cir.cast bitcast [[TMP5]] : !cir.ptr<i8> -> !cir.ptr<!void>
 // AFTER-NEXT: cir.store{{.*}} [[NEW_STACK_V]], [[STACK_P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: cir.br [[BB_END]]([[STACK_V]] : !cir.ptr<!void>)
 
 // 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:  [[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:   cir.store{{.*}} [[TMP1]], [[RESP]] : !cir.double, !cir.ptr<!cir.double>
 // AFTER:   cir.va.end [[VARLIST]] : !cir.ptr<!rec___va_list>
diff --git a/clang/test/CIR/CodeGen/var-arg-scope.c b/clang/test/CIR/CodeGen/var-arg-scope.c
index dc99abde8927..e5d236f7a980 100644
--- a/clang/test/CIR/CodeGen/var-arg-scope.c
+++ b/clang/test/CIR/CodeGen/var-arg-scope.c
@@ -38,9 +38,9 @@ void f1(__builtin_va_list c) {
 // 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: [[TMP2:%.*]] = cir.cast(bitcast, [[GR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
+// AFTER-NEXT: [[TMP2:%.*]] = cir.cast bitcast [[GR_TOP]] : !cir.ptr<!void> -> !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride [[TMP2]], [[GR_OFFS]] : (!cir.ptr<i8>, !s32i) -> !cir.ptr<i8>
-// AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast(bitcast, [[TMP3]] : !cir.ptr<i8>), !cir.ptr<!void>
+// AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast bitcast [[TMP3]] : !cir.ptr<i8> -> !cir.ptr<!void>
 // AFTER-NEXT: cir.br [[BB_END:\^bb.*]]([[IN_REG_OUTPUT]] : !cir.ptr<!void>)
 
 // arg is passed in stack.
@@ -48,9 +48,9 @@ void f1(__builtin_va_list c) {
 // 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: [[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: [[TMP4:%.*]] = cir.cast bitcast [[STACK_V]] : !cir.ptr<!void> -> !cir.ptr<i8>
 // AFTER-NEXT: [[TMP5:%.*]] = cir.ptr_stride [[TMP4]], [[EIGHT_IN_PTR_ARITH]] : (!cir.ptr<i8>, !u64i) -> !cir.ptr<i8>
-// AFTER-NEXT: [[NEW_STACK_V:%.*]] = cir.cast(bitcast, [[TMP5]] : !cir.ptr<i8>), !cir.ptr<!void>
+// AFTER-NEXT: [[NEW_STACK_V:%.*]] = cir.cast bitcast [[TMP5]] : !cir.ptr<i8> -> !cir.ptr<!void>
 // AFTER-NEXT: cir.store [[NEW_STACK_V]], [[STACK_P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: cir.br [[BB_END]]([[STACK_V]] : !cir.ptr<!void>)
 
@@ -59,7 +59,7 @@ void f1(__builtin_va_list c) {
 // stack's argument saving area.
 // 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<!cir.ptr<!void>>
+// AFTER-NEXT:  [[TMP0:%.*]] = cir.cast bitcast [[BLK_ARG]] : !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT:  [[TMP1:%.*]] = cir.load [[TMP0]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // AFTER-NEXT: cir.yield
 // AFTER-NEXT: }
diff --git a/clang/test/CIR/CodeGen/var-arg.c b/clang/test/CIR/CodeGen/var-arg.c
index 7c167c62d227..0427eeef4c0d 100644
--- a/clang/test/CIR/CodeGen/var-arg.c
+++ b/clang/test/CIR/CodeGen/var-arg.c
@@ -49,9 +49,9 @@ int f1(int n, ...) {
 // 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: [[TMP2:%.*]] = cir.cast(bitcast, [[GR_TOP]] : !cir.ptr<!void>), !cir.ptr<i8>
+// AFTER-NEXT: [[TMP2:%.*]] = cir.cast bitcast [[GR_TOP]] : !cir.ptr<!void> -> !cir.ptr<i8>
 // AFTER-NEXT: [[TMP3:%.*]] = cir.ptr_stride [[TMP2]], [[GR_OFFS]] : (!cir.ptr<i8>, !s32i) -> !cir.ptr<i8>
-// AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast(bitcast, [[TMP3]] : !cir.ptr<i8>), !cir.ptr<!void>
+// AFTER-NEXT: [[IN_REG_OUTPUT:%.*]] = cir.cast bitcast [[TMP3]] : !cir.ptr<i8> -> !cir.ptr<!void>
 // AFTER-NEXT: cir.br [[BB_END:\^bb.*]]([[IN_REG_OUTPUT]] : !cir.ptr<!void>)
 
 // arg is passed in stack.
@@ -59,9 +59,9 @@ int f1(int n, ...) {
 // 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: [[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: [[TMP4:%.*]] = cir.cast bitcast [[STACK_V]] : !cir.ptr<!void> -> !cir.ptr<i8>
 // AFTER-NEXT: [[TMP5:%.*]] = cir.ptr_stride [[TMP4]], [[EIGHT_IN_PTR_ARITH]] : (!cir.ptr<i8>, !u64i) -> !cir.ptr<i8>
-// AFTER-NEXT: [[NEW_STACK_V:%.*]] = cir.cast(bitcast, [[TMP5]] : !cir.ptr<i8>), !cir.ptr<!void>
+// AFTER-NEXT: [[NEW_STACK_V:%.*]] = cir.cast bitcast [[TMP5]] : !cir.ptr<i8> -> !cir.ptr<!void>
 // AFTER-NEXT: cir.store{{.*}} [[NEW_STACK_V]], [[STACK_P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
 // AFTER-NEXT: cir.br [[BB_END]]([[STACK_V]] : !cir.ptr<!void>)
 
@@ -70,7 +70,7 @@ int f1(int n, ...) {
 // stack's argument saving area.
 // 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:  [[TMP0:%.*]] = cir.cast bitcast [[BLK_ARG]] : !cir.ptr<!void> -> !cir.ptr<!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>
diff --git a/clang/test/CIR/CodeGen/vector.cpp b/clang/test/CIR/CodeGen/vector.cpp
index c524b8339771..f5a1dd8f590e 100644
--- a/clang/test/CIR/CodeGen/vector.cpp
+++ b/clang/test/CIR/CodeGen/vector.cpp
@@ -22,7 +22,7 @@ namespace std {
 // CHECK:   cir.store{{.*}} %4, %2 : !u64i, !cir.ptr<!u64i>
 // CHECK:   cir.scope {
 // CHECK:     %5 = cir.load{{.*}} %2 : !cir.ptr<!u64i>, !u64i
-// CHECK:     %6 = cir.cast(int_to_bool, %5 : !u64i), !cir.bool
+// CHECK:     %6 = cir.cast int_to_bool %5 : !u64i -> !cir.bool
 // CHECK:     cir.if %6 {
 // CHECK:     }
 // CHECK:   }
diff --git a/clang/test/CIR/CodeGen/vectype-ext.cpp b/clang/test/CIR/CodeGen/vectype-ext.cpp
index 48fe65b59c50..b13c23dae993 100644
--- a/clang/test/CIR/CodeGen/vectype-ext.cpp
+++ b/clang/test/CIR/CodeGen/vectype-ext.cpp
@@ -87,7 +87,7 @@ void vector_int_test(int x) {
   // Vector to vector conversion
   vd2 bbb = { };
   bb = (vi4)bbb;
-  // CIR: %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.vector<!cir.double x 2>), !cir.vector<!s32i x 4>
+  // CIR: %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.vector<!cir.double x 2> -> !cir.vector<!s32i x 4>
   // LLVM: %{{[0-9]+}} = bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
 
   // Extract element
@@ -335,7 +335,7 @@ void vector_double_test(int x, double y) {
 
   // __builtin_convertvector
   vus2 w = __builtin_convertvector(a, vus2);
-  // CIR: %{{[0-9]+}} = cir.cast(float_to_int, %{{[0-9]+}} : !cir.vector<!cir.double x 2>), !cir.vector<!u16i x 2>
+  // CIR: %{{[0-9]+}} = cir.cast float_to_int %{{[0-9]+}} : !cir.vector<!cir.double x 2> -> !cir.vector<!u16i x 2>
   // LLVM: %{{[0-9]+}} = fptoui <2 x double> %{{[0-9]+}} to <2 x i16>
 }
 
@@ -532,7 +532,7 @@ void test_vec3() {
   // LLVM-NEXT: store <3 x i32> zeroinitializer, ptr %[[#PV]], align 16
 
   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: %[[#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: %[[#POISON6:]] = cir.const #cir.poison : !cir.vector<!s32i x 4>
   // CIR-NEXT: %[[#V3:]] = cir.vec.shuffle(%[[#V4]], %[[#POISON6]] : !cir.vector<!s32i x 4>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i] : !cir.vector<!s32i x 3>
diff --git a/clang/test/CIR/CodeGen/vectype.cpp b/clang/test/CIR/CodeGen/vectype.cpp
index 13e5e54794d3..3b449b694da0 100644
--- a/clang/test/CIR/CodeGen/vectype.cpp
+++ b/clang/test/CIR/CodeGen/vectype.cpp
@@ -44,7 +44,7 @@ void vector_int_test(int x, unsigned short usx) {
   // Vector to vector conversion
   vd2 bbb = { };
   bb = (vi4)bbb;
-  // CHECK: %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.vector<!cir.double x 2>), !cir.vector<!s32i x 4>
+  // CHECK: %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.vector<!cir.double x 2> -> !cir.vector<!s32i x 4>
 
   // Extract element
   int c = a[x];
@@ -136,15 +136,15 @@ void vector_int_test(int x, unsigned short usx) {
 
   // Vector to scalar conversion
   unsigned int zi = (unsigned int)z;
-  // CHECK: %{{[0-9]+}} = cir.cast(bitcast, {{%.*}} : !cir.vector<!u16i x 2>), !u32i
+  // CHECK: %{{[0-9]+}} = cir.cast bitcast {{%.*}} : !cir.vector<!u16i x 2> -> !u32i
 
   // Scalar to vector conversion
   vus2 zz = (vus2)zi;
-  // CHECK: %{{[0-9]+}} = cir.cast(bitcast, {{%.*}} : !u32i), !cir.vector<!u16i x 2>
+  // CHECK: %{{[0-9]+}} = cir.cast bitcast {{%.*}} : !u32i -> !cir.vector<!u16i x 2>
 
   // Vector to vector conversion
   vll2 aaa = (vll2)a;
-  // CHECK: %{{[0-9]+}} = cir.cast(bitcast, {{%.*}} : !cir.vector<!s32i x 4>), !cir.vector<!s64i x 2>
+  // CHECK: %{{[0-9]+}} = cir.cast bitcast {{%.*}} : !cir.vector<!s32i x 4> -> !cir.vector<!s64i x 2>
 }
 
 void vector_double_test(int x, double y) {
@@ -209,7 +209,7 @@ void vector_double_test(int x, double y) {
 
   // __builtin_convertvector
   vus2 w = __builtin_convertvector(a, vus2);
-  // CHECK: %{{[0-9]+}} = cir.cast(float_to_int, %{{[0-9]+}} : !cir.vector<!cir.double x 2>), !cir.vector<!u16i x 2>
+  // CHECK: %{{[0-9]+}} = cir.cast float_to_int %{{[0-9]+}} : !cir.vector<!cir.double x 2> -> !cir.vector<!u16i x 2>
 }
 
 void vector_integers_shifts_test() {
diff --git a/clang/test/CIR/CodeGen/virtual-base-cast.cpp b/clang/test/CIR/CodeGen/virtual-base-cast.cpp
index b8e26a21f366..bd16c960c6d4 100644
--- a/clang/test/CIR/CodeGen/virtual-base-cast.cpp
+++ b/clang/test/CIR/CodeGen/virtual-base-cast.cpp
@@ -23,13 +23,13 @@ A* a() { return x; }
 // CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
 // CIR: %[[X_VPTR_ADDR:.*]] = cir.vtable.get_vptr %[[X]] : !cir.ptr<!rec_D> -> !cir.ptr<!cir.vptr>
 // CIR: %[[X_VPTR_BASE:.*]] = cir.load{{.*}} %[[X_VPTR_ADDR]] : !cir.ptr<!cir.vptr>, !cir.vptr
-// CIR: %[[X_BASE_I8PTR:.*]] = cir.cast(bitcast, %[[X_VPTR_BASE]] : !cir.vptr), !cir.ptr<!u8i>
+// CIR: %[[X_BASE_I8PTR:.*]] = cir.cast bitcast %[[X_VPTR_BASE]] : !cir.vptr -> !cir.ptr<!u8i>
 // CIR:  %[[OFFSET_OFFSET:.*]] = cir.const #cir.int<-32> : !s64i
 // CIR:  %[[OFFSET_PTR:.*]] = cir.ptr_stride %[[X_BASE_I8PTR]], %[[OFFSET_OFFSET]] : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
-// CIR:  %[[OFFSET_PTR_CAST:.*]] = cir.cast(bitcast, %[[OFFSET_PTR]] : !cir.ptr<!u8i>), !cir.ptr<!s64i>
+// 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:  %[[VBASE_ADDR:.*]] = cir.ptr_stride {{.*}}, %[[OFFSET]] : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
-// CIR:  cir.cast(bitcast, %[[VBASE_ADDR]] : !cir.ptr<!u8i>), !cir.ptr<!rec_D>
+// CIR:  cir.cast bitcast %[[VBASE_ADDR]] : !cir.ptr<!u8i> -> !cir.ptr<!rec_D>
 
 // FIXME: this version should include null check.
 // LLVM-LABEL: @_Z1av()
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index b3133e271691..b185ec73eb03 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -5,7 +5,7 @@
 // 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:    [[TMP3:%.*]] = cir.cast(integral, [[TMP2]] : !s32i), !u64i
+// 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}
diff --git a/clang/test/CIR/CodeGen/vtt.cpp b/clang/test/CIR/CodeGen/vtt.cpp
index e5916091d042..1983946115d2 100644
--- a/clang/test/CIR/CodeGen/vtt.cpp
+++ b/clang/test/CIR/CodeGen/vtt.cpp
@@ -51,20 +51,20 @@ int f() {
 // Class B constructor
 // CIR: cir.func linkonce_odr @_ZN1BC2Ev(%arg0: !cir.ptr<!rec_B>
 // CIR:   %{{[0-9]+}} = cir.vtt.address_point %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>, offset = 0 -> !cir.ptr<!cir.ptr<!void>>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!cir.vptr>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.vptr>
 // CIR:   %{{[0-9]+}} = cir.load align(8) %{{[0-9]+}} : !cir.ptr<!cir.vptr>, !cir.vptr
 // CIR:   %{{[0-9]+}} = cir.vtable.get_vptr %{{[0-9]+}} : !cir.ptr<!rec_B> -> !cir.ptr<!cir.vptr>
 // CIR:   cir.store{{.*}} %{{[0-9]+}}, %{{[0-9]+}} : !cir.vptr, !cir.ptr<!cir.vptr>
 
 // 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.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!cir.vptr>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.vptr>
 // CIR:   %{{[0-9]+}} = cir.load align(8) %{{[0-9]+}} : !cir.ptr<!cir.vptr>, !cir.vptr
 // CIR:   %{{[0-9]+}} = cir.vtable.get_vptr %{{.*}} : !cir.ptr<!rec_B> -> !cir.ptr<!cir.vptr>
 // CIR:   %{{[0-9]+}} = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vptr>, !cir.vptr
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.vptr), !cir.ptr<!u8i>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.vptr -> !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.const #cir.int<-24> : !s64i
 // CIR:   %{{[0-9]+}} = cir.ptr_stride %{{[0-9]+}}, %{{[0-9]+}} : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!u8i>), !cir.ptr<!s64i>
+// 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.ptr_stride %{{[0-9]+}}, %{{[0-9]+}} : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.vtable.get_vptr %{{[0-9]+}} : !cir.ptr<!rec_B> -> !cir.ptr<!cir.vptr>
@@ -85,23 +85,23 @@ int f() {
 // Class C constructor
 // CIR: cir.func linkonce_odr @_ZN1CC2Ev(%arg0: !cir.ptr<!rec_C>
 // CIR:   %{{[0-9]+}} = cir.vtt.address_point %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>, offset = 0 -> !cir.ptr<!cir.ptr<!void>>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!cir.vptr>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.vptr>
 // CIR:   %{{[0-9]+}} = cir.load align(8) %{{[0-9]+}} : !cir.ptr<!cir.vptr>, !cir.vptr
 // CIR:   %{{[0-9]+}} = cir.vtable.get_vptr %{{[0-9]+}} : !cir.ptr<!rec_C> -> !cir.ptr<!cir.vptr>
 // CIR:   cir.store{{.*}} %{{[0-9]+}}, %{{[0-9]+}} : !cir.vptr, !cir.ptr<!cir.vptr>
 
 // 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.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!cir.vptr>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.vptr>
 // CIR:   %{{[0-9]+}} = cir.load align(8) %{{[0-9]+}} : !cir.ptr<!cir.vptr>, !cir.vptr
 // CIR:   %{{[0-9]+}} = cir.vtable.get_vptr %{{[0-9]+}} : !cir.ptr<!rec_C> -> !cir.ptr<!cir.vptr>
 // CIR:   %{{[0-9]+}} = cir.load{{.*}} %{{[0-9]+}} : !cir.ptr<!cir.vptr>, !cir.vptr
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.vptr), !cir.ptr<!u8i>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.vptr -> !cir.ptr<!u8i>
 // CIR:   %{{[0-9]+}} = cir.const #cir.int<-24> : !s64i
 // CIR:   %{{[0-9]+}} = cir.ptr_stride %{{[0-9]+}}, %{{[0-9]+}} : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!u8i>), !cir.ptr<!s64i>
+// 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.ptr_stride %{{[0-9]+}}, %{{[0-9]+}} : (!cir.ptr<!u8i>, !s64i) -> !cir.ptr<!u8i>
-// CIR:   %{{[0-9]+}} = cir.cast(bitcast, %{{[0-9]+}} : !cir.ptr<!u8i>), !cir.ptr<!rec_C>
+// CIR:   %{{[0-9]+}} = cir.cast bitcast %{{[0-9]+}} : !cir.ptr<!u8i> -> !cir.ptr<!rec_C>
 // CIR:   %{{[0-9]+}} = cir.vtable.get_vptr %{{[0-9]+}} : !cir.ptr<!rec_C> -> !cir.ptr<!cir.vptr>
 // CIR:   cir.store{{.*}} %{{[0-9]+}}, %{{[0-9]+}} : !cir.vptr, !cir.ptr<!cir.vptr>
 // CIR: }
diff --git a/clang/test/CIR/IR/cast.cir b/clang/test/CIR/IR/cast.cir
index 8523439a7c2c..890b4055dd6a 100644
--- a/clang/test/CIR/IR/cast.cir
+++ b/clang/test/CIR/IR/cast.cir
@@ -4,30 +4,30 @@
 module  {
   cir.func @yolo(%arg0 : !s32i) {
     %0 = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["x", init]
-    %a = cir.cast (int_to_bool, %arg0 : !s32i), !cir.bool
+    %a = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
 
-    %3 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 10>>), !cir.ptr<!s32i>
+    %3 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
     %4 = cir.const #cir.int<0> : !s32i
     cir.return
   }
 
   cir.func @bitcast(%p: !cir.ptr<!s32i>) {
-    %2 = cir.cast(bitcast, %p : !cir.ptr<!s32i>), !cir.ptr<f32>
+    %2 = cir.cast bitcast %p : !cir.ptr<!s32i> -> !cir.ptr<f32>
     cir.return
   }
 
   cir.func @addrspace_cast(%arg0: !cir.ptr<!s32i>) {
-    %0 = cir.cast(address_space, %arg0 : !cir.ptr<!s32i>), !cir.ptr<!s32i, addrspace(target<2>)>
+    %0 = cir.cast address_space %arg0 : !cir.ptr<!s32i> -> !cir.ptr<!s32i, addrspace(target<2>)>
     cir.return
   }
 }
 
 // CHECK: cir.func @yolo(%arg0: !s32i)
-// CHECK: %1 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
-// CHECK: %2 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 10>>), !cir.ptr<!s32i>
+// CHECK: %1 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
+// CHECK: %2 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
 
 // CHECK: cir.func @bitcast
-// CHECK: %0 = cir.cast(bitcast, %arg0 : !cir.ptr<!s32i>), !cir.ptr<f32>
+// CHECK: %0 = cir.cast bitcast %arg0 : !cir.ptr<!s32i> -> !cir.ptr<f32>
 
 // CHECK: cir.func @addrspace_cast
-// CHECK: %0 = cir.cast(address_space, %arg0 : !cir.ptr<!s32i>), !cir.ptr<!s32i, addrspace(target<2>)>
+// CHECK: %0 = cir.cast address_space %arg0 : !cir.ptr<!s32i> -> !cir.ptr<!s32i, addrspace(target<2>)>
diff --git a/clang/test/CIR/IR/cir-ops.cir b/clang/test/CIR/IR/cir-ops.cir
index 2c2d137ab92e..c59f5cda5c0c 100644
--- a/clang/test/CIR/IR/cir-ops.cir
+++ b/clang/test/CIR/IR/cir-ops.cir
@@ -30,7 +30,7 @@ module  {
     %2 = cir.const #cir.int<0> : !s32i
     cir.store %2, %0 : !s32i, !cir.ptr<!s32i>
     %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
-    %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %3 : !s32i -> !cir.bool
     cir.if %4 {
       %6 = cir.const #cir.int<3> : !s32i
       cir.store %6, %0 : !s32i, !cir.ptr<!s32i>
@@ -87,7 +87,7 @@ module  {
 // CHECK-NEXT:   }
 
 // CHECK:   @if0(%arg0: !s32i) -> !s32i {
-// CHECK:   %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool
+// CHECK:   %4 = cir.cast int_to_bool %3 : !s32i -> !cir.bool
 // CHECK-NEXT:   cir.if %4 {
 // CHECK-NEXT:     %6 = cir.const #cir.int<3> : !s32i
 // CHECK-NEXT:     cir.store %6, %0 : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/IR/exceptions.cir b/clang/test/CIR/IR/exceptions.cir
index 1ff552f344ed..3940a663fdb4 100644
--- a/clang/test/CIR/IR/exceptions.cir
+++ b/clang/test/CIR/IR/exceptions.cir
@@ -29,7 +29,7 @@ module {
         %13 = cir.load %1 : !cir.ptr<!s32i>, !s32i
         %14 = cir.load %2 : !cir.ptr<!s32i>, !s32i
         %15 = cir.try_call exception(%10) @_Z8divisionii(%13, %14) : (!s32i, !s32i) -> !cir.double
-        %16 = cir.cast(float_to_int, %15 : !cir.double), !u64i
+        %16 = cir.cast float_to_int %15 : !cir.double -> !u64i
         cir.store %16, %3 : !u64i, !cir.ptr<!u64i>
         %17 = cir.load %11 : !cir.ptr<!s32i>, !s32i
         %18 = cir.unary(inc, %17) : !s32i, !s32i
@@ -41,7 +41,7 @@ module {
         %11 = cir.load %10 : !cir.ptr<!s32i>, !s32i
         cir.store %11, %9 : !s32i, !cir.ptr<!s32i>
         %12 = cir.const #cir.int<98> : !s32i
-        %13 = cir.cast(integral, %12 : !s32i), !u64i
+        %13 = cir.cast integral %12 : !s32i -> !u64i
         cir.store %13, %3 : !u64i, !cir.ptr<!u64i>
         %14 = cir.load %9 : !cir.ptr<!s32i>, !s32i
         %15 = cir.unary(inc, %14) : !s32i, !s32i
@@ -51,7 +51,7 @@ module {
         %10 = cir.catch_param -> !cir.ptr<!s8i>
         cir.store %10, %8 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
         %11 = cir.const #cir.int<99> : !s32i
-        %12 = cir.cast(integral, %11 : !s32i), !u64i
+        %12 = cir.cast integral %11 : !s32i -> !u64i
         cir.store %12, %3 : !u64i, !cir.ptr<!u64i>
         %13 = cir.load %8 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
         %14 = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/IR/invalid.cir b/clang/test/CIR/IR/invalid.cir
index 9048092cb922..7edfbdf5933d 100644
--- a/clang/test/CIR/IR/invalid.cir
+++ b/clang/test/CIR/IR/invalid.cir
@@ -107,14 +107,14 @@ cir.func @badstride(%x: !cir.ptr<!cir.int<s, 32>>) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast0(%arg0: !u32i) {
-  %1 = cir.cast(int_to_bool, %arg0 : !u32i), !u32i // expected-error {{requires !cir.bool type for result}}
+  %1 = cir.cast int_to_bool %arg0 : !u32i -> !u32i // expected-error {{requires !cir.bool type for result}}
   cir.return
 }
 
 // -----
 
 cir.func @cast1(%arg1: !cir.float) {
-  %1 = cir.cast(int_to_bool, %arg1 : !cir.float), !cir.bool // expected-error {{requires !cir.int type for source}}
+  %1 = cir.cast int_to_bool %arg1 : !cir.float -> !cir.bool // expected-error {{requires !cir.int type for source}}
   cir.return
 }
 
@@ -122,7 +122,7 @@ cir.func @cast1(%arg1: !cir.float) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast2(%p: !cir.ptr<!u32i>) {
-  %2 = cir.cast(array_to_ptrdecay, %p : !cir.ptr<!u32i>), !cir.ptr<!u32i> // expected-error {{requires !cir.array pointee}}
+  %2 = cir.cast array_to_ptrdecay %p : !cir.ptr<!u32i> -> !cir.ptr<!u32i> // expected-error {{requires !cir.array pointee}}
   cir.return
 }
 
@@ -131,7 +131,7 @@ cir.func @cast2(%p: !cir.ptr<!u32i>) {
 !u32i = !cir.int<u, 32>
 cir.func @cast3(%p: !cir.ptr<!u32i>) {
   %0 = cir.alloca !cir.array<!u32i x 10>, !cir.ptr<!cir.array<!u32i x 10>>, ["x", init]
-  %2 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!u32i x 10>>), !cir.ptr<!cir.float> // expected-error {{requires same type for array element and pointee result}}
+  %2 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!u32i x 10>> -> !cir.ptr<!cir.float> // expected-error {{requires same type for array element and pointee result}}
   cir.return
 }
 
@@ -139,21 +139,21 @@ cir.func @cast3(%p: !cir.ptr<!u32i>) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast4(%p: !cir.ptr<!u32i>) {
-  %2 = cir.cast(bitcast, %p : !cir.ptr<!u32i>), !u32i // expected-error {{requires !cir.ptr or !cir.vector type for source and result}}
+  %2 = cir.cast bitcast %p : !cir.ptr<!u32i> -> !u32i // expected-error {{requires !cir.ptr or !cir.vector type for source and result}}
   cir.return
 }
 
 // -----
 
 cir.func @cast5(%p: !cir.float) {
-  %2 = cir.cast(bool_to_float, %p : !cir.float), !cir.float // expected-error {{requires !cir.bool type for source}}
+  %2 = cir.cast bool_to_float %p : !cir.float -> !cir.float // expected-error {{requires !cir.bool type for source}}
   cir.return
 }
 
 // -----
 
 cir.func @cast6(%p: !cir.bool) {
-  %2 = cir.cast(bool_to_float, %p : !cir.bool), !cir.int<u, 32> // expected-error {{requires !cir.float type for result}}
+  %2 = cir.cast bool_to_float %p : !cir.bool -> !cir.int<u, 32> // expected-error {{requires !cir.float type for result}}
   cir.return
 }
 
@@ -161,7 +161,7 @@ cir.func @cast6(%p: !cir.bool) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast7(%p: !cir.ptr<!u32i>) {
-  %2 = cir.cast(ptr_to_bool, %p : !cir.ptr<!u32i>), !u32i // expected-error {{requires !cir.bool type for result}}
+  %2 = cir.cast ptr_to_bool %p : !cir.ptr<!u32i> -> !u32i // expected-error {{requires !cir.bool type for result}}
   cir.return
 }
 
@@ -169,7 +169,7 @@ cir.func @cast7(%p: !cir.ptr<!u32i>) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast8(%p: !u32i) {
-  %2 = cir.cast(ptr_to_bool, %p : !u32i), !cir.bool // expected-error {{requires !cir.ptr type for source}}
+  %2 = cir.cast ptr_to_bool %p : !u32i -> !cir.bool // expected-error {{requires !cir.ptr type for source}}
   cir.return
 }
 
@@ -177,7 +177,7 @@ cir.func @cast8(%p: !u32i) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast9(%p : !u32i) {
-  %2 = cir.cast(integral, %p : !u32i), !cir.float // expected-error {{requires !cir.int type for result}}
+  %2 = cir.cast integral %p : !u32i -> !cir.float // expected-error {{requires !cir.int type for result}}
   cir.return
 }
 
@@ -185,7 +185,7 @@ cir.func @cast9(%p : !u32i) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast10(%p : !cir.float) {
-  %2 = cir.cast(integral, %p : !cir.float), !u32i // expected-error {{requires !cir.int type for source}}
+  %2 = cir.cast integral %p : !cir.float -> !u32i // expected-error {{requires !cir.int type for source}}
   cir.return
 }
 
@@ -193,7 +193,7 @@ cir.func @cast10(%p : !cir.float) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast11(%p : !cir.float) {
-  %2 = cir.cast(floating, %p : !cir.float), !u32i // expected-error {{requires !cir.float type for source and result}}
+  %2 = cir.cast floating %p : !cir.float -> !u32i // expected-error {{requires !cir.float type for source and result}}
   cir.return
 }
 
@@ -201,7 +201,7 @@ cir.func @cast11(%p : !cir.float) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast12(%p : !u32i) {
-  %2 = cir.cast(floating, %p : !u32i), !cir.float // expected-error {{requires !cir.float type for source and result}}
+  %2 = cir.cast floating %p : !u32i -> !cir.float // expected-error {{requires !cir.float type for source and result}}
   cir.return
 }
 
@@ -209,14 +209,14 @@ cir.func @cast12(%p : !u32i) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast13(%p : !u32i) {
-  %2 = cir.cast(float_to_int, %p : !u32i), !u32i // expected-error {{requires !cir.float type for source}}
+  %2 = cir.cast float_to_int %p : !u32i -> !u32i // expected-error {{requires !cir.float type for source}}
   cir.return
 }
 
 // -----
 
 cir.func @cast14(%p : !cir.float) {
-  %2 = cir.cast(float_to_int, %p : !cir.float), !cir.float // expected-error {{requires !cir.int type for result}}
+  %2 = cir.cast float_to_int %p : !cir.float -> !cir.float // expected-error {{requires !cir.int type for result}}
   cir.return
 }
 
@@ -224,7 +224,7 @@ cir.func @cast14(%p : !cir.float) {
 
 !u64i = !cir.int<u, 64>
 cir.func @cast15(%p : !cir.ptr<!u64i>) {
-  %2 = cir.cast(int_to_ptr, %p : !cir.ptr<!u64i>), !cir.ptr<!u64i> // expected-error {{requires !cir.int type for source}}
+  %2 = cir.cast int_to_ptr %p : !cir.ptr<!u64i> -> !cir.ptr<!u64i> // expected-error {{requires !cir.int type for source}}
   cir.return
 }
 
@@ -232,7 +232,7 @@ cir.func @cast15(%p : !cir.ptr<!u64i>) {
 
 !u64i = !cir.int<u, 64>
 cir.func @cast16(%p : !u64i) {
-  %2 = cir.cast(int_to_ptr, %p : !u64i), !u64i // expected-error {{requires !cir.ptr type for result}}
+  %2 = cir.cast int_to_ptr %p : !u64i -> !u64i // expected-error {{requires !cir.ptr type for result}}
   cir.return
 }
 
@@ -240,7 +240,7 @@ cir.func @cast16(%p : !u64i) {
 
 !u64i = !cir.int<u, 64>
 cir.func @cast17(%p : !u64i) {
-  %2 = cir.cast(ptr_to_int, %p : !u64i), !u64i // expected-error {{requires !cir.ptr type for source}}
+  %2 = cir.cast ptr_to_int %p : !u64i -> !u64i // expected-error {{requires !cir.ptr type for source}}
   cir.return
 }
 
@@ -248,7 +248,7 @@ cir.func @cast17(%p : !u64i) {
 
 !u64i = !cir.int<u, 64>
 cir.func @cast18(%p : !cir.ptr<!u64i>) {
-  %2 = cir.cast(ptr_to_int, %p : !cir.ptr<!u64i>), !cir.ptr<!u64i> // expected-error {{requires !cir.int type for result}}
+  %2 = cir.cast ptr_to_int %p : !cir.ptr<!u64i> -> !cir.ptr<!u64i> // expected-error {{requires !cir.int type for result}}
   cir.return
 }
 
@@ -256,7 +256,7 @@ cir.func @cast18(%p : !cir.ptr<!u64i>) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast19(%p : !u32i) {
-  %2 = cir.cast(float_to_bool, %p : !u32i), !cir.bool // expected-error {{requires !cir.float type for source}}
+  %2 = cir.cast float_to_bool %p : !u32i -> !cir.bool // expected-error {{requires !cir.float type for source}}
   cir.return
 }
 
@@ -264,7 +264,7 @@ cir.func @cast19(%p : !u32i) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast20(%p : !cir.float) {
-  %2 = cir.cast(float_to_bool, %p : !cir.float), !u32i // expected-error {{requires !cir.bool type for result}}
+  %2 = cir.cast float_to_bool %p : !cir.float -> !u32i // expected-error {{requires !cir.bool type for result}}
   cir.return
 }
 
@@ -272,21 +272,21 @@ cir.func @cast20(%p : !cir.float) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast21(%p : !u32i) {
-  %2 = cir.cast(bool_to_int, %p : !u32i), !u32i // expected-error {{requires !cir.bool type for source}}
+  %2 = cir.cast bool_to_int %p : !u32i -> !u32i // expected-error {{requires !cir.bool type for source}}
   cir.return
 }
 
 // -----
 
 cir.func @cast22(%p : !cir.bool) {
-  %2 = cir.cast(bool_to_int, %p : !cir.bool), !cir.float // expected-error {{requires !cir.int type for result}}
+  %2 = cir.cast bool_to_int %p : !cir.bool -> !cir.float // expected-error {{requires !cir.int type for result}}
   cir.return
 }
 
 // -----
 
 cir.func @cast23(%p : !cir.bool) {
-  %2 = cir.cast(int_to_float, %p : !cir.bool), !cir.float // expected-error {{requires !cir.int type for source}}
+  %2 = cir.cast int_to_float %p : !cir.bool -> !cir.float // expected-error {{requires !cir.int type for source}}
   cir.return
 }
 
@@ -294,7 +294,7 @@ cir.func @cast23(%p : !cir.bool) {
 
 !u32i = !cir.int<u, 32>
 cir.func @cast24(%p : !u32i) {
-  %2 = cir.cast(int_to_float, %p : !u32i), !cir.bool // expected-error {{requires !cir.float type for result}}
+  %2 = cir.cast int_to_float %p : !u32i -> !cir.bool // expected-error {{requires !cir.float type for result}}
   cir.return
 }
 
@@ -303,7 +303,7 @@ cir.func @cast24(%p : !u32i) {
 !u32i = !cir.int<u, 32>
 !u64i = !cir.int<u, 64>
 cir.func @cast25(%p : !cir.ptr<!u32i, addrspace(target<1>)>) {
-  %0 = cir.cast(address_space, %p : !cir.ptr<!u32i, addrspace(target<1>)>), !cir.ptr<!u64i, addrspace(target<2>)> // expected-error {{requires two types differ in addrspace only}}
+  %0 = cir.cast address_space %p : !cir.ptr<!u32i, addrspace(target<1>)> -> !cir.ptr<!u64i, addrspace(target<2>)> // expected-error {{requires two types differ in addrspace only}}
   cir.return
 }
 
@@ -311,7 +311,7 @@ cir.func @cast25(%p : !cir.ptr<!u32i, addrspace(target<1>)>) {
 
 !u64i = !cir.int<u, 64>
 cir.func @cast26(%p : !cir.ptr<!u64i, addrspace(target<1>)>) {
-  %0 = cir.cast(address_space, %p : !cir.ptr<!u64i, addrspace(target<1>)>), !u64i // expected-error {{requires !cir.ptr type for source and result}}
+  %0 = cir.cast address_space %p : !cir.ptr<!u64i, addrspace(target<1>)> -> !u64i // expected-error {{requires !cir.ptr type for source and result}}
   cir.return
 }
 
@@ -319,7 +319,7 @@ cir.func @cast26(%p : !cir.ptr<!u64i, addrspace(target<1>)>) {
 
 !u64i = !cir.int<u, 64>
 cir.func @cast27(%p : !u64i) {
-  %0 = cir.cast(address_space, %p : !u64i), !cir.ptr<!u64i, addrspace(target<1>)> // expected-error {{requires !cir.ptr type for source and result}}
+  %0 = cir.cast address_space %p : !u64i -> !cir.ptr<!u64i, addrspace(target<1>)> // expected-error {{requires !cir.ptr type for source and result}}
   cir.return
 }
 
@@ -790,7 +790,7 @@ module {
   cir.func @_Z8divisionii() {
     %11 = cir.alloc.exception 8 -> !cir.ptr<!cir.ptr<!u8i>>
     %12 = cir.get_global @".str" : !cir.ptr<!cir.array<!u8i x 28>>
-    %13 = cir.cast(array_to_ptrdecay, %12 : !cir.ptr<!cir.array<!u8i x 28>>), !cir.ptr<!u8i>
+    %13 = cir.cast array_to_ptrdecay %12 : !cir.ptr<!cir.array<!u8i x 28>> -> !cir.ptr<!u8i>
     cir.store %13, %11 : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
     cir.throw %11 : !cir.ptr<!cir.ptr<!u8i>> // expected-error {{'type_info' symbol attribute missing}}
   }
@@ -1386,7 +1386,7 @@ module {
   cir.func @array_to_ptrdecay_addrspace() {
     %0 = cir.alloca !cir.array<!s32i x 32>, !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_private)>, ["x", init]
     // expected-error@+1 {{requires same address space for source and result}}
-    %1 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_private)>), !cir.ptr<!s32i>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_private)> -> !cir.ptr<!s32i>
     cir.return
   }
 }
@@ -1415,7 +1415,7 @@ module {
   cir.func @test_bitcast_addrspace() {
     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp"] {alignment = 4 : i64}
     // expected-error@+1 {{'cir.cast' op result type address space does not match the address space of the operand}}
-    %1 = cir.cast(bitcast, %0 : !cir.ptr<!s32i>), !cir.ptr<!s32i, addrspace(offload_local)>
+    %1 = cir.cast bitcast %0 : !cir.ptr<!s32i> -> !cir.ptr<!s32i, addrspace(offload_local)>
   }
 }
 
@@ -1429,7 +1429,7 @@ module {
     %0 = cir.const #cir.int<1> : !s16i
     %1 = cir.vec.create(%0, %0 : !s16i, !s16i) : !cir.vector<!s16i x 2>
     // expected-error@+1 {{'cir.cast' op requires !cir.ptr or !cir.vector type for source and result}}
-    %2 = cir.cast(bitcast, %1 : !cir.vector<!s16i x 2>), !s64i
+    %2 = cir.cast bitcast %1 : !cir.vector<!s16i x 2> -> !s64i
     cir.return
   }
 }
@@ -1443,7 +1443,7 @@ module {
   cir.func @test_bitcast_scalar2vec_diff_size() {
     %0 = cir.const #cir.int<1> : !s64i
     // expected-error@+1 {{'cir.cast' op requires !cir.ptr or !cir.vector type for source and result}}
-    %1 = cir.cast(bitcast, %0 : !s64i), !cir.vector<!s32i x 4>
+    %1 = cir.cast bitcast %0 : !s64i -> !cir.vector<!s32i x 4>
     cir.return
   }
 }
@@ -1646,14 +1646,14 @@ cir.global external dso_local @glob = #cir.zero : !rec_S {alignment = 2 : i64}
 cir.func dso_local @main() -> !s32i extra(#fn_attr) {
   %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
   %1 = cir.const #cir.int<0> : !s32i
-  %2 = cir.cast(integral, %1 : !s32i), !s16i
+  %2 = cir.cast integral %1 : !s32i -> !s16i
   %3 = cir.get_global @glob : !cir.ptr<!rec_S>
   %4 = cir.get_member %3[0] {name = "i"} : !cir.ptr<!rec_S> -> !cir.ptr<!s16i>
   cir.store align(2) %2, %4 : !s16i, !cir.ptr<!s16i> tbaa(#tbaa_tag)
   %5 = cir.get_global @glob : !cir.ptr<!rec_S>
   %6 = cir.get_member %5[0] {name = "i"} : !cir.ptr<!rec_S> -> !cir.ptr<!s16i>
   %7 = cir.load align(2) %6 : !cir.ptr<!s16i>, !s16i tbaa(#tbaa_tag)
-  %8 = cir.cast(integral, %7 : !s16i), !s32i
+  %8 = cir.cast integral %7 : !s16i -> !s32i
   cir.store %8, %0 : !s32i, !cir.ptr<!s32i>
   %9 = cir.load %0 : !cir.ptr<!s32i>, !s32i
   cir.return %9 : !s32i
diff --git a/clang/test/CIR/IR/ptr_stride.cir b/clang/test/CIR/IR/ptr_stride.cir
index 856404e2f309..725c9b12d2e4 100644
--- a/clang/test/CIR/IR/ptr_stride.cir
+++ b/clang/test/CIR/IR/ptr_stride.cir
@@ -4,8 +4,8 @@
 module  {
   cir.func @arraysubscript(%arg0: !s32i) {
     %0 = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["x", init]
-    %1 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
-    %2 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 10>>), !cir.ptr<!s32i>
+    %1 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
+    %2 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
     %3 = cir.const #cir.int<0> : !s32i
     %4 = cir.ptr_stride %2, %3 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
     cir.return
@@ -22,8 +22,8 @@ module  {
 
 // CHECK: cir.func @arraysubscript(%arg0: !s32i) {
 // CHECK-NEXT:    %0 = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["x", init]
-// CHECK-NEXT:    %1 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
-// CHECK-NEXT:    %2 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<!s32i x 10>>), !cir.ptr<!s32i>
+// CHECK-NEXT:    %1 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
+// CHECK-NEXT:    %2 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
 // CHECK-NEXT:    %3 = cir.const #cir.int<0> : !s32i
 // CHECK-NEXT:    %4 = cir.ptr_stride %2, %3 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
 // CHECK-NEXT:    cir.return
diff --git a/clang/test/CIR/IR/tbaa-parse.cir b/clang/test/CIR/IR/tbaa-parse.cir
index f7479a926242..dd3de33d27e2 100644
--- a/clang/test/CIR/IR/tbaa-parse.cir
+++ b/clang/test/CIR/IR/tbaa-parse.cir
@@ -14,14 +14,14 @@ cir.global external dso_local @glob = #cir.zero : !rec_S {alignment = 2 : i64}
 cir.func dso_local @main() -> !s32i extra(#fn_attr) {
   %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
   %1 = cir.const #cir.int<0> : !s32i
-  %2 = cir.cast(integral, %1 : !s32i), !s16i
+  %2 = cir.cast integral %1 : !s32i -> !s16i
   %3 = cir.get_global @glob : !cir.ptr<!rec_S>
   %4 = cir.get_member %3[0] {name = "i"} : !cir.ptr<!rec_S> -> !cir.ptr<!s16i>
   cir.store align(2) %2, %4 : !s16i, !cir.ptr<!s16i> tbaa(#tbaa_tag)
   %5 = cir.get_global @glob : !cir.ptr<!rec_S>
   %6 = cir.get_member %5[0] {name = "i"} : !cir.ptr<!rec_S> -> !cir.ptr<!s16i>
   %7 = cir.load align(2) %6 : !cir.ptr<!s16i>, !s16i tbaa(#tbaa_tag)
-  %8 = cir.cast(integral, %7 : !s16i), !s32i
+  %8 = cir.cast integral %7 : !s16i -> !s32i
   cir.store %8, %0 : !s32i, !cir.ptr<!s32i>
   %9 = cir.load %0 : !cir.ptr<!s32i>, !s32i
   cir.return %9 : !s32i
diff --git a/clang/test/CIR/Lowering/ThroughMLIR/cast.cir b/clang/test/CIR/Lowering/ThroughMLIR/cast.cir
index 8812e77dd583..8c5f8f770965 100644
--- a/clang/test/CIR/Lowering/ThroughMLIR/cast.cir
+++ b/clang/test/CIR/Lowering/ThroughMLIR/cast.cir
@@ -14,7 +14,7 @@ module {
     // MLIR-NEXT: arith.cmpi ne, %arg0, %[[ZERO]]
     // LLVM-NEXT: icmp ne i32 %0, 0
 
-    %1 = cir.cast(int_to_bool, %i : !u32i), !cir.bool
+    %1 = cir.cast int_to_bool %i : !u32i -> !cir.bool
     cir.return %1 : !cir.bool
   }
   // MLIR-LABEL: func.func @cast_integral_trunc(%arg0: i32) -> i16
@@ -23,7 +23,7 @@ module {
     // MLIR-NEXT: arith.trunci %arg0 : i32 to i16
     // LLVM-NEXT: trunc i32 %0 to i16
 
-    %1 = cir.cast(integral, %i : !u32i), !u16i
+    %1 = cir.cast integral %i : !u32i -> !u16i
     cir.return %1 : !u16i
   }
   // MLIR-LABEL: func.func @cast_integral_extu(%arg0: i16) -> i32
@@ -32,7 +32,7 @@ module {
     // MLIR-NEXT: arith.extui %arg0 : i16 to i32
     // LLVM-NEXT: zext i16 %0 to i32
 
-    %1 = cir.cast(integral, %i : !u16i), !u32i
+    %1 = cir.cast integral %i : !u16i -> !u32i
     cir.return %1 : !u32i
   }
   // MLIR-LABEL: func.func @cast_integral_exts(%arg0: i16) -> i32
@@ -41,7 +41,7 @@ module {
     // MLIR-NEXT: arith.extsi %arg0 : i16 to i32
     // LLVM-NEXT: sext i16 %0 to i32
 
-    %1 = cir.cast(integral, %i : !s16i), !s32i
+    %1 = cir.cast integral %i : !s16i -> !s32i
     cir.return %1 : !s32i
   }
   // MLIR-LABEL: func.func @cast_integral_same_size(%arg0: i32) -> i32
@@ -50,7 +50,7 @@ module {
     // MLIR-NEXT: %0 = arith.bitcast %arg0 : i32 to i32
     // LLVM-NEXT: ret i32 %0
 
-    %1 = cir.cast(integral, %i : !u32i), !s32i
+    %1 = cir.cast integral %i : !u32i -> !s32i
     cir.return %1 : !s32i
   }
   // MLIR-LABEL: func.func @cast_floating_trunc(%arg0: f64) -> f32
@@ -59,7 +59,7 @@ module {
     // MLIR-NEXT: arith.truncf %arg0 : f64 to f32
     // LLVM-NEXT: fptrunc double %0 to float
 
-    %1 = cir.cast(floating, %d : !cir.double), !cir.float
+    %1 = cir.cast floating %d : !cir.double -> !cir.float
     cir.return %1 : !cir.float
   }
   // MLIR-LABEL: func.func @cast_floating_extf(%arg0: f32) -> f64
@@ -68,7 +68,7 @@ module {
     // MLIR-NEXT: arith.extf %arg0 : f32 to f64
     // LLVM-NEXT: fpext float %0 to double
 
-    %1 = cir.cast(floating, %f : !cir.float), !cir.double
+    %1 = cir.cast floating %f : !cir.float -> !cir.double
     cir.return %1 : !cir.double
   }
   // MLIR-LABEL: func.func @cast_float_to_bool(%arg0: f32) -> i1
@@ -78,7 +78,7 @@ module {
     // MLIR-NEXT: arith.cmpf une, %arg0, %[[ZERO]] : f32
     // LLVM-NEXT: fcmp une float %0, 0.000000e+00
 
-    %1 = cir.cast(float_to_bool, %f : !cir.float), !cir.bool
+    %1 = cir.cast float_to_bool %f : !cir.float -> !cir.bool
     cir.return %1 : !cir.bool
   }
   // MLIR-LABEL: func.func @cast_bool_to_int8(%arg0: i1) -> i8
@@ -87,7 +87,7 @@ module {
     // MLIR-NEXT: arith.extui %arg0 : i1 to i8
     // LLVM-NEXT: zext i1 %0 to i8
 
-    %1 = cir.cast(bool_to_int, %b : !cir.bool), !u8i
+    %1 = cir.cast bool_to_int %b : !cir.bool -> !u8i
     cir.return %1 : !u8i
   }
   // MLIR-LABEL: func.func @cast_bool_to_int(%arg0: i1) -> i32
@@ -96,7 +96,7 @@ module {
     // MLIR-NEXT: arith.extui %arg0 : i1 to i32
     // LLVM-NEXT: zext i1 %0 to i32
 
-    %1 = cir.cast(bool_to_int, %b : !cir.bool), !u32i
+    %1 = cir.cast bool_to_int %b : !cir.bool -> !u32i
     cir.return %1 : !u32i
   }
   // MLIR-LABEL: func.func @cast_bool_to_float(%arg0: i1) -> f32
@@ -105,7 +105,7 @@ module {
     // MLIR-NEXT: arith.uitofp %arg0 : i1 to f32
     // LLVM-NEXT: uitofp i1 %0 to float
 
-    %1 = cir.cast(bool_to_float, %b : !cir.bool), !cir.float
+    %1 = cir.cast bool_to_float %b : !cir.bool -> !cir.float
     cir.return %1 : !cir.float
   }
   // MLIR-LABEL: func.func @cast_signed_int_to_float(%arg0: i32) -> f32
@@ -114,7 +114,7 @@ module {
     // MLIR-NEXT: arith.sitofp %arg0 : i32 to f32
     // LLVM-NEXT: sitofp i32 %0 to float
 
-    %1 = cir.cast(int_to_float, %i : !s32i), !cir.float
+    %1 = cir.cast int_to_float %i : !s32i -> !cir.float
     cir.return %1 : !cir.float
   }
   // MLIR-LABEL: func.func @cast_unsigned_int_to_float(%arg0: i32) -> f32
@@ -123,7 +123,7 @@ module {
     // MLIR-NEXT: arith.uitofp %arg0 : i32 to f32
     // LLVM-NEXT: uitofp i32 %0 to float
 
-    %1 = cir.cast(int_to_float, %i : !u32i), !cir.float
+    %1 = cir.cast int_to_float %i : !u32i -> !cir.float
     cir.return %1 : !cir.float
   }
   // MLIR-LABEL: func.func @cast_float_to_int_signed(%arg0: f32) -> i32
@@ -132,7 +132,7 @@ module {
     // MLIR-NEXT: arith.fptosi %arg0 : f32 to i32
     // LLVM-NEXT: fptosi float %0 to i32
 
-    %1 = cir.cast(float_to_int, %f : !cir.float), !s32i
+    %1 = cir.cast float_to_int %f : !cir.float -> !s32i
     cir.return %1 : !s32i
   }
   // MLIR-LABEL: func.func @cast_float_to_int_unsigned(%arg0: f32) -> i32
@@ -141,7 +141,7 @@ module {
     // MLIR-NEXT: arith.fptoui %arg0 : f32 to i32
     // LLVM-NEXT: fptoui float %0 to i32
 
-    %1 = cir.cast(float_to_int, %f : !cir.float), !u32i
+    %1 = cir.cast float_to_int %f : !cir.float -> !u32i
     cir.return %1 : !u32i
   }
 }
diff --git a/clang/test/CIR/Lowering/ThroughMLIR/ptrstride.cir b/clang/test/CIR/Lowering/ThroughMLIR/ptrstride.cir
index 880ee5ad9348..38d8b21785bb 100644
--- a/clang/test/CIR/Lowering/ThroughMLIR/ptrstride.cir
+++ b/clang/test/CIR/Lowering/ThroughMLIR/ptrstride.cir
@@ -19,7 +19,7 @@ module {
 
     %1 = cir.get_global @a : !cir.ptr<!cir.array<!s32i x 100>>
     %2 = cir.const #cir.int<1> : !s32i
-    %3 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s32i x 100>>), !cir.ptr<!s32i>
+    %3 = cir.cast array_to_ptrdecay %1 : !cir.ptr<!cir.array<!s32i x 100>> -> !cir.ptr<!s32i>
     %4 = cir.ptr_stride %3, %2 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
     %5 = cir.load %4 : !cir.ptr<!s32i>, !s32i
     cir.return %5 : !s32i
@@ -40,10 +40,10 @@ module {
 
     %1 = cir.get_global @aa : !cir.ptr<!cir.array<!cir.array<!s32i x 100> x 100>>
     %2 = cir.const #cir.int<1> : !s32i
-    %3 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!cir.array<!s32i x 100> x 100>>), !cir.ptr<!cir.array<!s32i x 100>>
+    %3 = cir.cast array_to_ptrdecay %1 : !cir.ptr<!cir.array<!cir.array<!s32i x 100> x 100>> -> !cir.ptr<!cir.array<!s32i x 100>>
     %4 = cir.ptr_stride %3, %2 : (!cir.ptr<!cir.array<!s32i x 100>>, !s32i) -> !cir.ptr<!cir.array<!s32i x 100>>
     %5 = cir.const #cir.int<2> : !s32i
-    %6 = cir.cast(array_to_ptrdecay, %4 : !cir.ptr<!cir.array<!s32i x 100>>), !cir.ptr<!s32i>
+    %6 = cir.cast array_to_ptrdecay %4 : !cir.ptr<!cir.array<!s32i x 100>> -> !cir.ptr<!s32i>
     %7 = cir.ptr_stride %6, %5 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
     %8 = cir.load %7 : !cir.ptr<!s32i>, !s32i
     cir.return %8 : !s32i
@@ -68,7 +68,7 @@ module {
     %0 = cir.const #cir.int<2> : !s32i
     %1 = cir.get_global @a : !cir.ptr<!cir.array<!s32i x 100>>
     %2 = cir.const #cir.int<1> : !s32i
-    %3 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s32i x 100>>), !cir.ptr<!s32i>
+    %3 = cir.cast array_to_ptrdecay %1 : !cir.ptr<!cir.array<!s32i x 100>> -> !cir.ptr<!s32i>
     %4 = cir.ptr_stride %3, %2 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
     %5 = cir.load %4 : !cir.ptr<!s32i>, !s32i
     %6 = cir.binop(add, %5, %0) : !s32i
diff --git a/clang/test/CIR/Lowering/bitint.cir b/clang/test/CIR/Lowering/bitint.cir
index 61db545b0d07..2303b92a6f68 100644
--- a/clang/test/CIR/Lowering/bitint.cir
+++ b/clang/test/CIR/Lowering/bitint.cir
@@ -5,10 +5,10 @@
 
 module {
   cir.func @ParamPassing(%arg0: !cir.int<s, 15>, %arg1: !cir.int<s, 31>) -> !cir.int<s, 2> {
-    %0 = cir.cast(integral, %arg0 : !cir.int<s, 15>), !s32i
-    %1 = cir.cast(integral, %arg1 : !cir.int<s, 31>), !s32i
+    %0 = cir.cast integral %arg0 : !cir.int<s, 15> -> !s32i
+    %1 = cir.cast integral %arg1 : !cir.int<s, 31> -> !s32i
     %2 = cir.binop(add, %0, %1) : !s32i
-    %3 = cir.cast(integral, %2 : !s32i), !cir.int<s, 2>
+    %3 = cir.cast integral %2 : !s32i -> !cir.int<s, 2>
     cir.return %3 : !cir.int<s, 2>
   }
 }
diff --git a/clang/test/CIR/Lowering/bool-to-int.cir b/clang/test/CIR/Lowering/bool-to-int.cir
index 97ee3c1daee0..c9b46715422e 100644
--- a/clang/test/CIR/Lowering/bool-to-int.cir
+++ b/clang/test/CIR/Lowering/bool-to-int.cir
@@ -7,12 +7,12 @@
 module {
   cir.func @foo(%arg0: !s32i, %arg1: !s32i) -> !s32i {
     %1 = cir.const #true
-    %2 = cir.cast(bool_to_int, %1 : !cir.bool), !s32i
+    %2 = cir.cast bool_to_int %1 : !cir.bool -> !s32i
     cir.return %2 : !s32i
   }
   cir.func @bar(%arg0: !s32i, %arg1: !s32i) -> !s32i {
     %1 = cir.const #false
-    %2 = cir.cast(bool_to_int, %1 : !cir.bool), !s32i
+    %2 = cir.cast bool_to_int %1 : !cir.bool -> !s32i
     cir.return %2 : !s32i
   }
 }
diff --git a/clang/test/CIR/Lowering/brcond.cir b/clang/test/CIR/Lowering/brcond.cir
index 19e778cef823..41722a54af49 100644
--- a/clang/test/CIR/Lowering/brcond.cir
+++ b/clang/test/CIR/Lowering/brcond.cir
@@ -5,7 +5,7 @@
 #fn_attr = #cir<extra({inline = #cir.inline<no>, nothrow = #cir.nothrow, optnone = #cir.optnone})>
 module { cir.func no_proto @test() -> !cir.bool extra(#fn_attr) {
     %0 = cir.const #cir.int<0> : !s32i
-    %1 = cir.cast(int_to_bool, %0 : !s32i), !cir.bool
+    %1 = cir.cast int_to_bool %0 : !s32i -> !cir.bool
     cir.br ^bb1
   ^bb1:
     cir.brcond %1 ^bb2, ^bb3
diff --git a/clang/test/CIR/Lowering/cast.cir b/clang/test/CIR/Lowering/cast.cir
index 7b731794f1fa..68f5a6d7180c 100644
--- a/clang/test/CIR/Lowering/cast.cir
+++ b/clang/test/CIR/Lowering/cast.cir
@@ -27,54 +27,54 @@ module {
 
     // Integer casts.
     %9 = cir.load %0 : !cir.ptr<!u32i>, !u32i
-    %10 = cir.cast(integral, %9 : !u32i), !s8i
+    %10 = cir.cast integral %9 : !u32i -> !s8i
     // CHECK: %{{[0-9]+}} = llvm.trunc %{{[0-9]+}} : i32 to i8
     cir.store %10, %3 : !s8i, !cir.ptr<!s8i>
     %11 = cir.load %1 : !cir.ptr<!s32i>, !s32i
-    %12 = cir.cast(integral, %11 : !s32i), !s16i
+    %12 = cir.cast integral %11 : !s32i -> !s16i
     // CHECK: %{{[0-9]+}} = llvm.trunc %{{[0-9]+}} : i32 to i16
     cir.store %12, %4 : !s16i, !cir.ptr<!s16i>
     %13 = cir.load %0 : !cir.ptr<!u32i>, !u32i
-    %14 = cir.cast(integral, %13 : !u32i), !s64i
+    %14 = cir.cast integral %13 : !u32i -> !s64i
     // CHECK: %{{[0-9]+}} = llvm.zext %{{[0-9]+}} : i32 to i64
     cir.store %14, %5 : !s64i, !cir.ptr<!s64i>
     %15 = cir.load %1 : !cir.ptr<!s32i>, !s32i
-    %16 = cir.cast(integral, %15 : !s32i), !s64i
+    %16 = cir.cast integral %15 : !s32i -> !s64i
     // CHECK: %{{[0-9]+}} = llvm.sext %{{[0-9]+}} : i32 to i64
-    %30 = cir.cast(integral, %arg1 : !s32i), !u32i
+    %30 = cir.cast integral %arg1 : !s32i -> !u32i
     // Should not produce a cast.
-    %32 = cir.cast(integral, %arg0 : !u32i), !s32i
+    %32 = cir.cast integral %arg0 : !u32i -> !s32i
     // Should not produce a cast.
     %21 = cir.load %20 : !cir.ptr<!s16i>, !s16i
-    %22 = cir.cast(integral, %21 : !s16i), !u64i
+    %22 = cir.cast integral %21 : !s16i -> !u64i
     // CHECK: %[[TMP:[0-9]+]] = llvm.sext %{{[0-9]+}} : i16 to i64
-    %33 = cir.cast(int_to_bool, %arg1 : !s32i), !cir.bool
+    %33 = cir.cast int_to_bool %arg1 : !s32i -> !cir.bool
     // CHECK: %[[#ZERO:]] = llvm.mlir.constant(0 : i32) : i32
     // CHECK: %[[#CMP:]] = llvm.icmp "ne" %arg1, %[[#ZERO]] : i32
 
     // Pointer casts.
     cir.store %16, %6 : !s64i, !cir.ptr<!s64i>
-    %17 = cir.cast(array_to_ptrdecay, %7 : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
+    %17 = cir.cast array_to_ptrdecay %7 : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
     cir.store %17, %8 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
     // CHECK: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, i32
-    %23 = cir.cast(int_to_ptr, %22 : !u64i), !cir.ptr<!u8i>
+    %23 = cir.cast int_to_ptr %22 : !u64i -> !cir.ptr<!u8i>
     // CHECK: %[[TMP2:[0-9]+]] = llvm.inttoptr %[[TMP]] : i64 to !llvm.ptr
-    %24 = cir.cast(ptr_to_int, %23 : !cir.ptr<!u8i>), !s32i
+    %24 = cir.cast ptr_to_int %23 : !cir.ptr<!u8i> -> !s32i
     // CHECK: %{{[0-9]+}} = llvm.ptrtoint %[[TMP2]] : !llvm.ptr to i32
-    %29 = cir.cast(ptr_to_bool, %23 : !cir.ptr<!u8i>), !cir.bool
+    %29 = cir.cast ptr_to_bool %23 : !cir.ptr<!u8i> -> !cir.bool
 
     // Floating point casts.
-    %25 = cir.cast(int_to_float, %arg1 : !s32i), !cir.float
+    %25 = cir.cast int_to_float %arg1 : !s32i -> !cir.float
     // CHECK: %{{.+}} = llvm.sitofp %{{.+}} : i32 to f32
-    %26 = cir.cast(int_to_float, %arg0 : !u32i), !cir.float
+    %26 = cir.cast int_to_float %arg0 : !u32i -> !cir.float
     // CHECK: %{{.+}} = llvm.uitofp %{{.+}} : i32 to f32
-    %27 = cir.cast(float_to_int, %arg2 : !cir.float), !s32i
+    %27 = cir.cast float_to_int %arg2 : !cir.float -> !s32i
     // CHECK: %{{.+}} = llvm.fptosi %{{.+}} : f32 to i32
-    %28 = cir.cast(float_to_int, %arg2 : !cir.float), !u32i
+    %28 = cir.cast float_to_int %arg2 : !cir.float -> !u32i
     // CHECK: %{{.+}} = llvm.fptoui %{{.+}} : f32 to i32
     %18 = cir.const #cir.int<0> : !s32i
     // CHECK: %{{.+}} = llvm.fptrunc %{{.+}} : f64 to f32
-    %34 = cir.cast(floating, %arg3 : !cir.double), !cir.float
+    %34 = cir.cast floating %arg3 : !cir.double -> !cir.float
 
     cir.store %18, %2 : !s32i, !cir.ptr<!s32i>
     %19 = cir.load %2 : !cir.ptr<!s32i>, !s32i
@@ -88,7 +88,7 @@ module {
     cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
 
     %2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
-    %3 = cir.cast(bool_to_int, %2 : !cir.bool), !u8i
+    %3 = cir.cast bool_to_int %2 : !cir.bool -> !u8i
     // CHECK: %[[LOAD_BOOL:.*]] = llvm.load %{{.*}} : !llvm.ptr -> i8
     // CHECK: %[[TRUNC:.*]] = llvm.trunc %[[LOAD_BOOL]] : i8 to i1
     // CHECK: %[[EXT:.*]] = llvm.zext %[[TRUNC]] : i1 to i8
@@ -101,7 +101,7 @@ module {
   cir.func @testArrayToPtrDecay() {
     // CHECK-LABEL: llvm.func @testArrayToPtrDecay()
     %null_bool_array = cir.const #cir.ptr<null> : !cir.ptr<!cir.array<!cir.bool x 3>>
-    %bool_array_decay = cir.cast(array_to_ptrdecay, %null_bool_array : !cir.ptr<!cir.array<!cir.bool x 3>>), !cir.ptr<!cir.bool>
+    %bool_array_decay = cir.cast array_to_ptrdecay %null_bool_array : !cir.ptr<!cir.array<!cir.bool x 3>> -> !cir.ptr<!cir.bool>
     // CHECK: = llvm.getelementptr %{{.*}}[0] : (!llvm.ptr) -> !llvm.ptr, i8
     %res = cir.load %bool_array_decay : !cir.ptr<!cir.bool>, !cir.bool
     // CHECK-NEXT: %[[BOOL_LOAD:.+]] = llvm.load %{{.*}} {{.*}} : !llvm.ptr -> i8
diff --git a/clang/test/CIR/Lowering/exceptions.cir b/clang/test/CIR/Lowering/exceptions.cir
index cad089de30b8..cfda43d075aa 100644
--- a/clang/test/CIR/Lowering/exceptions.cir
+++ b/clang/test/CIR/Lowering/exceptions.cir
@@ -38,7 +38,7 @@ module @"try-catch.cpp" attributes {cir.lang = #cir.lang<cxx>, cir.sob = #cir.si
     // LLVM:     to label %[[CONT:.*]] unwind label %[[UNWIND:.*]],
   ^bb3:
     // LLVM: [[CONT]]:
-    %13 = cir.cast(float_to_int, %12 : !cir.double), !u64i
+    %13 = cir.cast float_to_int %12 : !cir.double -> !u64i
     cir.store %13, %3 : !u64i, !cir.ptr<!u64i>
     %14 = cir.load %8 : !cir.ptr<!s32i>, !s32i
     %15 = cir.unary(inc, %14) : !s32i, !s32i
@@ -65,7 +65,7 @@ module @"try-catch.cpp" attributes {cir.lang = #cir.lang<cxx>, cir.sob = #cir.si
     %22 = cir.load %21 : !cir.ptr<!s32i>, !s32i
     cir.store %22, %7 : !s32i, !cir.ptr<!s32i>
     %23 = cir.const #cir.int<98> : !s32i
-    %24 = cir.cast(integral, %23 : !s32i), !u64i
+    %24 = cir.cast integral %23 : !s32i -> !u64i
     cir.store %24, %3 : !u64i, !cir.ptr<!u64i>
     %25 = cir.load %7 : !cir.ptr<!s32i>, !s32i
     %26 = cir.unary(inc, %25) : !s32i, !s32i
@@ -84,7 +84,7 @@ module @"try-catch.cpp" attributes {cir.lang = #cir.lang<cxx>, cir.sob = #cir.si
     // LLVM: call ptr @__cxa_begin_catch(ptr %[[EH_MSG]])
     cir.store %32, %6 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
     %33 = cir.const #cir.int<99> : !s32i
-    %34 = cir.cast(integral, %33 : !s32i), !u64i
+    %34 = cir.cast integral %33 : !s32i -> !u64i
     cir.store %34, %3 : !u64i, !cir.ptr<!u64i>
     %35 = cir.load %6 : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!s8i>
     %36 = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/Lowering/expect.cir b/clang/test/CIR/Lowering/expect.cir
index 57f9cf2e35da..346b097982fe 100644
--- a/clang/test/CIR/Lowering/expect.cir
+++ b/clang/test/CIR/Lowering/expect.cir
@@ -6,12 +6,12 @@ module {
   cir.func @foo(%arg0: !s64i) {
     %0 = cir.const #cir.int<1> : !s64i
     %1 = cir.expect(%arg0, %0) : !s64i
-    %2 = cir.cast(int_to_bool, %1 : !s64i), !cir.bool
+    %2 = cir.cast int_to_bool %1 : !s64i -> !cir.bool
     cir.if %2 {
       cir.yield
     }
     %3 = cir.expect(%arg0, %0, 1.000000e-01) : !s64i
-    %4 = cir.cast(int_to_bool, %3 : !s64i), !cir.bool
+    %4 = cir.cast int_to_bool %3 : !s64i -> !cir.bool
     cir.if %4 {
       cir.yield
     }
diff --git a/clang/test/CIR/Lowering/func.cir b/clang/test/CIR/Lowering/func.cir
index 241fdc364c02..9eb70b7c43e1 100644
--- a/clang/test/CIR/Lowering/func.cir
+++ b/clang/test/CIR/Lowering/func.cir
@@ -8,7 +8,7 @@ module {
   cir.func @test3(%arg0: !s32i) {
     %3 = cir.get_global @noProto3 : !cir.ptr<!cir.func<(...) -> !s32i>>
     // MLIR: %[[#FN_PTR:]] = llvm.mlir.addressof @noProto3 : !llvm.ptr
-    %4 = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<(...) -> !s32i>>), !cir.ptr<!cir.func<(!s32i) -> !s32i>>
+    %4 = cir.cast bitcast %3 : !cir.ptr<!cir.func<(...) -> !s32i>> -> !cir.ptr<!cir.func<(!s32i) -> !s32i>>
     // MLIR: %[[#FUNC:]] = llvm.bitcast %[[#FN_PTR]] : !llvm.ptr to !llvm.ptr
     %5 = cir.call %4(%arg0) : (!cir.ptr<!cir.func<(!s32i) -> !s32i>>, !s32i) -> !s32i
     // MLIR: %{{.+}} = llvm.call %[[#FUNC]](%{{.+}}) : !llvm.ptr, (i32) -> i32
diff --git a/clang/test/CIR/Lowering/globals.cir b/clang/test/CIR/Lowering/globals.cir
index 194e15d34fcc..2df4a29bb27d 100644
--- a/clang/test/CIR/Lowering/globals.cir
+++ b/clang/test/CIR/Lowering/globals.cir
@@ -65,7 +65,7 @@ module {
     %3 = cir.const #cir.int<0> : !s32i
     %4 = cir.ptr_stride %2, %3 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
     %5 = cir.load %4 : !cir.ptr<!s8i>, !s8i
-    %6 = cir.cast(integral, %5 : !s8i), !u8i
+    %6 = cir.cast integral %5 : !s8i -> !u8i
     cir.store %6, %0 : !u8i, !cir.ptr<!u8i>
     cir.return
   }
@@ -112,27 +112,27 @@ module {
     %3 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["si", init] {alignment = 8 : i64}
     %4 = cir.alloca !cir.ptr<!s64i>, !cir.ptr<!cir.ptr<!s64i>>, ["l", init] {alignment = 8 : i64}
     %5 = cir.get_global @string : !cir.ptr<!cir.array<!s8i x 8>>
-    %6 = cir.cast(array_to_ptrdecay, %5 : !cir.ptr<!cir.array<!s8i x 8>>), !cir.ptr<!s8i>
+    %6 = cir.cast array_to_ptrdecay %5 : !cir.ptr<!cir.array<!s8i x 8>> -> !cir.ptr<!s8i>
     // MLIR: %[[RES:[0-9]+]] = llvm.mlir.addressof @string : !llvm.ptr
     // MLIR: %{{[0-9]+}} = llvm.getelementptr %[[RES]][0] : (!llvm.ptr) -> !llvm.ptr, i8
     cir.store %6, %0 : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
     %7 = cir.get_global @uint : !cir.ptr<!cir.array<!u32i x 1>>
-    %8 = cir.cast(array_to_ptrdecay, %7 : !cir.ptr<!cir.array<!u32i x 1>>), !cir.ptr<!u32i>
+    %8 = cir.cast array_to_ptrdecay %7 : !cir.ptr<!cir.array<!u32i x 1>> -> !cir.ptr<!u32i>
     // MLIR: %[[RES:[0-9]+]] = llvm.mlir.addressof @uint : !llvm.ptr
     // MLIR: %{{[0-9]+}} = llvm.getelementptr %[[RES]][0] : (!llvm.ptr) -> !llvm.ptr, i32
     cir.store %8, %1 : !cir.ptr<!u32i>, !cir.ptr<!cir.ptr<!u32i>>
     %9 = cir.get_global @sshort : !cir.ptr<!cir.array<!s16i x 2>>
-    %10 = cir.cast(array_to_ptrdecay, %9 : !cir.ptr<!cir.array<!s16i x 2>>), !cir.ptr<!s16i>
+    %10 = cir.cast array_to_ptrdecay %9 : !cir.ptr<!cir.array<!s16i x 2>> -> !cir.ptr<!s16i>
     // MLIR: %[[RES:[0-9]+]] = llvm.mlir.addressof @sshort : !llvm.ptr
     // MLIR: %{{[0-9]+}} = llvm.getelementptr %[[RES]][0] : (!llvm.ptr) -> !llvm.ptr, i16
     cir.store %10, %2 : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
     %11 = cir.get_global @sint : !cir.ptr<!cir.array<!s32i x 3>>
-    %12 = cir.cast(array_to_ptrdecay, %11 : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
+    %12 = cir.cast array_to_ptrdecay %11 : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
     // MLIR: %[[RES:[0-9]+]] = llvm.mlir.addressof @sint : !llvm.ptr
     // MLIR: %{{[0-9]+}} = llvm.getelementptr %[[RES]][0] : (!llvm.ptr) -> !llvm.ptr, i32
     cir.store %12, %3 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
     %13 = cir.get_global @ll : !cir.ptr<!cir.array<!s64i x 4>>
-    %14 = cir.cast(array_to_ptrdecay, %13 : !cir.ptr<!cir.array<!s64i x 4>>), !cir.ptr<!s64i>
+    %14 = cir.cast array_to_ptrdecay %13 : !cir.ptr<!cir.array<!s64i x 4>> -> !cir.ptr<!s64i>
     // MLIR: %[[RES:[0-9]+]] = llvm.mlir.addressof @ll : !llvm.ptr
     // MLIR: %{{[0-9]+}} = llvm.getelementptr %[[RES]][0] : (!llvm.ptr) -> !llvm.ptr, i64
     cir.store %14, %4 : !cir.ptr<!s64i>, !cir.ptr<!cir.ptr<!s64i>>
@@ -177,7 +177,7 @@ module {
     cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
     %2 = cir.get_global @Handlers : !cir.ptr<!cir.array<!rec_anon2E1_ x 1>>
     %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-    %4 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!rec_anon2E1_ x 1>>), !cir.ptr<!rec_anon2E1_>
+    %4 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!rec_anon2E1_ x 1>> -> !cir.ptr<!rec_anon2E1_>
     %5 = cir.ptr_stride %4, %3 : (!cir.ptr<!rec_anon2E1_>, !s32i) -> !cir.ptr<!rec_anon2E1_>
     %6 = cir.get_member %5[0] {name = "func"} : !cir.ptr<!rec_anon2E1_> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
     %7 = cir.load %6 : !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>, !cir.ptr<!cir.func<(!s32i)>>
diff --git a/clang/test/CIR/Lowering/hello.cir b/clang/test/CIR/Lowering/hello.cir
index 361fa7ed36af..539e2d74974b 100644
--- a/clang/test/CIR/Lowering/hello.cir
+++ b/clang/test/CIR/Lowering/hello.cir
@@ -10,7 +10,7 @@ module @"/tmp/test.raw" attributes {cir.lang = #cir.lang<c>, cir.sob = #cir.sign
     %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
     %1 = cir.get_global @printf : !cir.ptr<!cir.func<(!cir.ptr<!s8i>, ...) -> !s32i>>
     %2 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 15>>
-    %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!s8i x 15>>), !cir.ptr<!s8i>
+    %3 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!s8i x 15>> -> !cir.ptr<!s8i>
     %4 = cir.call @printf(%3) : (!cir.ptr<!s8i>) -> !s32i
     %5 = cir.const #cir.int<0> : !s32i
     cir.store %5, %0 : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/Lowering/if.cir b/clang/test/CIR/Lowering/if.cir
index 44aa412ffd13..8968e1fa9ae5 100644
--- a/clang/test/CIR/Lowering/if.cir
+++ b/clang/test/CIR/Lowering/if.cir
@@ -4,7 +4,7 @@
 
 module {
   cir.func @foo(%arg0: !s32i) -> !s32i {
-    %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
     cir.if %4 {
       %5 = cir.const #cir.int<1> : !s32i
       cir.return %5 : !s32i
@@ -44,7 +44,7 @@ module {
 //  LLVM-NEXT: }
 
   cir.func @onlyIf(%arg0: !s32i) -> !s32i {
-    %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
     cir.if %4 {
       %5 = cir.const #cir.int<1> : !s32i
       cir.return %5 : !s32i
@@ -66,7 +66,7 @@ module {
   // Verify empty if clause is properly lowered to empty block
   cir.func @emptyIfClause(%arg0: !s32i) -> !s32i {
     // MLIR-LABEL: llvm.func @emptyIfClause
-    %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
     // MLIR: llvm.cond_br {{%.*}}, ^[[T:.*]], ^[[PHI:.*]]
     cir.if %4 {
       // MLIR-NEXT: ^[[T]]:
@@ -82,7 +82,7 @@ module {
   // addressed
   cir.func @emptyIfElseClause(%arg0: !s32i) -> !s32i {
     // MLIR-LABEL: llvm.func @emptyIfElseClause
-    %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
     // MLIR: llvm.cond_br {{%.*}}, ^[[T:.*]], ^[[F:.*]]
     cir.if %4 {
     // MLIR-NEXT: ^[[T]]:
diff --git a/clang/test/CIR/Lowering/loadstorealloca.cir b/clang/test/CIR/Lowering/loadstorealloca.cir
index 85f714dc6b51..582652d5f3de 100644
--- a/clang/test/CIR/Lowering/loadstorealloca.cir
+++ b/clang/test/CIR/Lowering/loadstorealloca.cir
@@ -50,7 +50,7 @@ module {
     %2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
     // MLIR: %[[LOAD_VAL:.*]] = llvm.load %[[VAR]] {alignment = 1 : i64} : !llvm.ptr -> i8
     // MLIR: %[[LOAD_SCALAR:.*]] = llvm.trunc %[[LOAD_VAL]] : i8 to i1
-    %3 = cir.cast(bool_to_int, %2 : !cir.bool), !u32i
+    %3 = cir.cast bool_to_int %2 : !cir.bool -> !u32i
     // MLIR: %[[CAST_VAL:.*]] = llvm.zext %[[LOAD_SCALAR]] : i1 to i32
     cir.return
   }
diff --git a/clang/test/CIR/Lowering/ptrdiff.cir b/clang/test/CIR/Lowering/ptrdiff.cir
index c0b1a4b3e314..6aacceab15fe 100644
--- a/clang/test/CIR/Lowering/ptrdiff.cir
+++ b/clang/test/CIR/Lowering/ptrdiff.cir
@@ -6,7 +6,7 @@
 module {
   cir.func @foo(%arg0: !cir.ptr<!s32i>, %arg1: !cir.ptr<!s32i>) -> !s32i {
     %1 = cir.ptr_diff(%arg0, %arg1) : !cir.ptr<!s32i> -> !u64i
-    %2 = cir.cast(integral, %1 : !u64i), !s32i
+    %2 = cir.cast integral %1 : !u64i -> !s32i
     cir.return %2 : !s32i
   }
 }
diff --git a/clang/test/CIR/Lowering/try-catch.cpp b/clang/test/CIR/Lowering/try-catch.cpp
index ca54cb027abd..a3eb0102abb9 100644
--- a/clang/test/CIR/Lowering/try-catch.cpp
+++ b/clang/test/CIR/Lowering/try-catch.cpp
@@ -21,7 +21,7 @@ unsigned long long tc() {
     z = division(x, y);
 
     // CIR_FLAT: ^[[CONT:.*]]:  // pred: ^bb2
-    // CIR_FLAT: cir.cast(float_to_int, %12 : !cir.double), !u64i
+    // CIR_FLAT: cir.cast float_to_int %12 : !cir.double -> !u64i
     a++;
     // CIR_FLAT: cir.br ^[[AFTER_TRY:.*]] loc
 
diff --git a/clang/test/CIR/Lowering/unary-not.cir b/clang/test/CIR/Lowering/unary-not.cir
index 35cd54f3df78..dd8372b132ed 100644
--- a/clang/test/CIR/Lowering/unary-not.cir
+++ b/clang/test/CIR/Lowering/unary-not.cir
@@ -28,14 +28,14 @@ module {
         cir.store %arg0, %0 : !cir.float, !cir.ptr<!cir.float>
         cir.store %arg1, %1 : !cir.double, !cir.ptr<!cir.double>
         %2 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
-        %3 = cir.cast(float_to_bool, %2 : !cir.float), !cir.bool
+        %3 = cir.cast float_to_bool %2 : !cir.float -> !cir.bool
         // MLIR: %[[#F_ZERO:]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
         // MLIR: %[[#F_BOOL:]] = llvm.fcmp "une" %{{.+}}, %[[#F_ZERO]] : f32
         %4 = cir.unary(not, %3) : !cir.bool, !cir.bool
         // MLIR: %[[#F_ONE:]] = llvm.mlir.constant(true) : i1
         // MLIR: = llvm.xor %[[#F_BOOL]], %[[#F_ONE]]  : i1
         %5 = cir.load %1 : !cir.ptr<!cir.double>, !cir.double
-        %6 = cir.cast(float_to_bool, %5 : !cir.double), !cir.bool
+        %6 = cir.cast float_to_bool %5 : !cir.double -> !cir.bool
         // MLIR: %[[#D_ZERO:]] = llvm.mlir.constant(0.000000e+00 : f64) : f64
         // MLIR: %[[#D_BOOL:]] = llvm.fcmp "une" %{{.+}}, %[[#D_ZERO]] : f64
         %7 = cir.unary(not, %6) : !cir.bool, !cir.bool
@@ -52,9 +52,9 @@ module {
         cir.store %arg1, %3 : !cir.float, !cir.ptr<!cir.float>
 
         %5 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-        %6 = cir.cast(int_to_bool, %5 : !s32i), !cir.bool
+        %6 = cir.cast int_to_bool %5 : !s32i -> !cir.bool
         %7 = cir.unary(not, %6) : !cir.bool, !cir.bool
-        %8 = cir.cast(bool_to_int, %7 : !cir.bool), !s32i
+        %8 = cir.cast bool_to_int %7 : !cir.bool -> !s32i
         // MLIR: %[[#INT:]] = llvm.load %{{.+}} : !llvm.ptr
         // MLIR: %[[#IZERO:]] = llvm.mlir.constant(0 : i32) : i32
         // MLIR: %[[#ICMP:]] = llvm.icmp "ne" %[[#INT]], %[[#IZERO]] : i32
@@ -63,9 +63,9 @@ module {
         // MLIR: = llvm.zext %[[#IXOR]] : i1 to i32
 
         %17 = cir.load %3 : !cir.ptr<!cir.float>, !cir.float
-        %18 = cir.cast(float_to_bool, %17 : !cir.float), !cir.bool
+        %18 = cir.cast float_to_bool %17 : !cir.float -> !cir.bool
         %19 = cir.unary(not, %18) : !cir.bool, !cir.bool
-        %20 = cir.cast(bool_to_int, %19 : !cir.bool), !s32i
+        %20 = cir.cast bool_to_int %19 : !cir.bool -> !s32i
         // MLIR: %[[#FLOAT:]] = llvm.load %{{.+}} : !llvm.ptr
         // MLIR: %[[#FZERO:]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
         // MLIR: %[[#FCMP:]] = llvm.fcmp "une" %[[#FLOAT]], %[[#FZERO]] : f32
diff --git a/clang/test/CIR/Lowering/var-arg-x86_64.c b/clang/test/CIR/Lowering/var-arg-x86_64.c
index dc16f02e5962..db2245911860 100644
--- a/clang/test/CIR/Lowering/var-arg-x86_64.c
+++ b/clang/test/CIR/Lowering/var-arg-x86_64.c
@@ -44,9 +44,9 @@ double f1(int n, ...) {
 // CIR: cir.func dso_local @f1
 // CIR: [[VA_LIST_ALLOCA:%.+]] = cir.alloca !cir.array<!rec___va_list_tag x 1>,
 // CIR: [[RES:%.+]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["res",
-// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast(array_to_ptrdecay, [[VA_LIST_ALLOCA]]
+// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast array_to_ptrdecay [[VA_LIST_ALLOCA]]
 // CIR: cir.va.start [[VASTED_VA_LIST]]
-// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast(array_to_ptrdecay, [[VA_LIST_ALLOCA]]
+// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast array_to_ptrdecay [[VA_LIST_ALLOCA]]
 // CIR: [[VAARG_RESULT:%.+]] = cir.scope
 // CIR: [[FP_OFFSET_P:%.+]] = cir.get_member [[VASTED_VA_LIST]][1] {name = "fp_offset"}
 // CIR: [[FP_OFFSET:%.+]] = cir.load [[FP_OFFSET_P]]
@@ -67,14 +67,14 @@ double f1(int n, ...) {
 // CIR: [[OVERFLOW_ARG_AREA_P:%.+]] = cir.get_member [[VASTED_VA_LIST]][2] {name = "overflow_arg_area"}
 // CIR: [[OVERFLOW_ARG_AREA:%.+]] = cir.load [[OVERFLOW_ARG_AREA_P]]
 // CIR: [[OFFSET:%.+]] = cir.const #cir.int<8>
-// CIR: [[CASTED:%.+]] = cir.cast(bitcast, [[OVERFLOW_ARG_AREA]] : !cir.ptr<!void>)
+// CIR: [[CASTED:%.+]] = cir.cast bitcast [[OVERFLOW_ARG_AREA]] : !cir.ptr<!void>
 // CIR: [[NEW_VALUE:%.+]] = cir.ptr_stride [[CASTED]], [[OFFSET]] : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
-// CIR: [[CASTED_P:%.+]] = cir.cast(bitcast, [[OVERFLOW_ARG_AREA_P]] : !cir.ptr<!cir.ptr<!void>>)
+// CIR: [[CASTED_P:%.+]] = cir.cast bitcast [[OVERFLOW_ARG_AREA_P]] : !cir.ptr<!cir.ptr<!void>>
 // CIR: cir.store [[NEW_VALUE]], [[CASTED_P]]
 // CIR: cir.br ^[[ContBlock]]([[OVERFLOW_ARG_AREA]]
 //
 // CIR: ^[[ContBlock]]([[ARG:.+]]: !cir.ptr
-// CIR: [[CASTED_ARG_P:%.+]] = cir.cast(bitcast, [[ARG]]
+// CIR: [[CASTED_ARG_P:%.+]] = cir.cast bitcast [[ARG]]
 // CIR: [[CASTED_ARG:%.+]] = cir.load align(16) [[CASTED_ARG_P]]
 // CIR: cir.yield [[CASTED_ARG]]
 //
@@ -113,18 +113,18 @@ long double f2(int n, ...) {
 // CIR: cir.func dso_local @f2
 // CIR: [[VA_LIST_ALLOCA:%.+]] = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["valist"]
 // CIR: [[RES:%.+]] = cir.alloca !cir.long_double<!cir.f80>, !cir.ptr<!cir.long_double<!cir.f80>>, ["res"
-// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast(array_to_ptrdecay, [[VA_LIST_ALLOCA]]
+// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast array_to_ptrdecay [[VA_LIST_ALLOCA]]
 // CIR: cir.va.start [[VASTED_VA_LIST]]
-// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast(array_to_ptrdecay, [[VA_LIST_ALLOCA]]
+// CIR: [[VASTED_VA_LIST:%.+]] = cir.cast array_to_ptrdecay [[VA_LIST_ALLOCA]]
 // CIR: [[OVERFLOW_AREA_P:%.+]] = cir.get_member [[VASTED_VA_LIST]][2] {name = "overflow_arg_area"}
 // CIR-DAG: [[OVERFLOW_AREA:%.+]] = cir.load [[OVERFLOW_AREA_P]]
-// CIR-DAG: [[CASTED:%.+]] = cir.cast(bitcast, [[OVERFLOW_AREA]] : !cir.ptr<!void>)
+// CIR-DAG: [[CASTED:%.+]] = cir.cast bitcast [[OVERFLOW_AREA]] : !cir.ptr<!void>
 // CIR-DAG: [[CONSTANT:%.+]] = cir.const #cir.int<15>
 // CIR-DAG: [[PTR_STRIDE:%.+]] = cir.ptr_stride [[CASTED]], [[CONSTANT]] : (!cir.ptr<!u8i>, !u32i) -> !cir.ptr<!u8i>
 // CIR-DAG: [[MINUS_ALIGN:%.+]] = cir.const #cir.int<-16>
 // CIR-DAG: [[ALIGNED:%.+]] = cir.ptr_mask([[PTR_STRIDE]], [[MINUS_ALIGN]]
 // CIR: [[ALIGN:%.+]] = cir.const #cir.int<16>
-// CIR: [[CAST_ALIGNED:%.+]] = cir.cast(bitcast, [[ALIGNED]] : !cir.ptr<!u8i>), !cir.ptr<!cir.long_double<!cir.f80>>
+// CIR: [[CAST_ALIGNED:%.+]] = cir.cast bitcast [[ALIGNED]] : !cir.ptr<!u8i> -> !cir.ptr<!cir.long_double<!cir.f80>>
 // CIR: [[CAST_ALIGNED_VALUE:%.+]] = cir.load [[CAST_ALIGNED]]
 // CIR: cir.store{{.*}} [[CAST_ALIGNED_VALUE]], [[RES]]
 // CIR. cir.via.end
@@ -180,9 +180,9 @@ const char *f3(va_list args) {
 // CIR:           %[[OVERFLOW_ARG_AREA_PTR:.*]] = cir.get_member %[[VALIST]][2] {name = "overflow_arg_area"} : !cir.ptr<!rec___va_list_tag> -> !cir.ptr<!cir.ptr<!void>>
 // CIR:           %[[OVERFLOW_ARG_AREA:.*]] = cir.load %[[OVERFLOW_ARG_AREA_PTR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
 // CIR:           %[[VAL_15:.*]] = cir.const #cir.int<8> : !s32i
-// CIR:           %[[CUR_OVERFLOW_ARG_AREA:.*]] = cir.cast(bitcast, %[[OVERFLOW_ARG_AREA]] : !cir.ptr<!void>), !cir.ptr<!s8i>
+// CIR:           %[[CUR_OVERFLOW_ARG_AREA:.*]] = cir.cast bitcast %[[OVERFLOW_ARG_AREA]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
 // CIR:           %[[NEW_OVERFLOW_ARG_AREA:.*]] = cir.ptr_stride %[[CUR_OVERFLOW_ARG_AREA]], %[[VAL_15]] : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
-// CIR:           %[[VAL_18:.*]] = cir.cast(bitcast, %[[OVERFLOW_ARG_AREA_PTR]] : !cir.ptr<!cir.ptr<!void>>), !cir.ptr<!cir.ptr<!s8i>>
+// CIR:           %[[VAL_18:.*]] = cir.cast bitcast %[[OVERFLOW_ARG_AREA_PTR]] : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!s8i>>
 // CIR:           cir.store %[[NEW_OVERFLOW_ARG_AREA]], %[[VAL_18]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CIR:           cir.br ^[[CONT_BB]](%[[OVERFLOW_ARG_AREA]] : !cir.ptr<!void>)
 
@@ -199,7 +199,7 @@ void f4(va_list args) {
 //                    ... // The contents are tested elsewhere.
 // CIR:               cir.yield {{.*}} : !s32i
 // CIR:             } : !s32i
-// CIR:             %[[CMP:.*]] = cir.cast(int_to_bool, %[[VAARG_RESULT]] : !s32i), !cir.bool
+// CIR:             %[[CMP:.*]] = cir.cast int_to_bool %[[VAARG_RESULT]] : !s32i -> !cir.bool
 // CIR:             cir.condition(%[[CMP]])
 // CIR:           } body {
 // CIR:             cir.yield
diff --git a/clang/test/CIR/Lowering/variadics.cir b/clang/test/CIR/Lowering/variadics.cir
index d549c9fd6a4a..44b67dea251e 100644
--- a/clang/test/CIR/Lowering/variadics.cir
+++ b/clang/test/CIR/Lowering/variadics.cir
@@ -14,20 +14,20 @@ module {
     %2 = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["args"] {alignment = 16 : i64}
     %3 = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["args_copy"] {alignment = 16 : i64}
     cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
-    %4 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>), !cir.ptr<!rec___va_list_tag>
+    %4 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
     cir.va.start %4 : !cir.ptr<!rec___va_list_tag>
     //      MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: llvm.intr.vastart %{{[0-9]+}} : !llvm.ptr
-    %5 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>), !cir.ptr<!rec___va_list_tag>
-    %6 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>), !cir.ptr<!rec___va_list_tag>
+    %5 = cir.cast array_to_ptrdecay %3 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
+    %6 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
     cir.va.copy %6 to %5 : !cir.ptr<!rec___va_list_tag>, !cir.ptr<!rec___va_list_tag>
     //      MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
     // MLIR-NEXT: llvm.intr.vacopy %13 to %{{[0-9]+}} : !llvm.ptr, !llvm.ptr
-    %7 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>), !cir.ptr<!rec___va_list_tag>
+    %7 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
     cir.va.end %7 : !cir.ptr<!rec___va_list_tag>
     //      MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)>
     // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr
diff --git a/clang/test/CIR/Lowering/vec-cmp.cir b/clang/test/CIR/Lowering/vec-cmp.cir
index 3bc6570444a7..cea94bd22eda 100644
--- a/clang/test/CIR/Lowering/vec-cmp.cir
+++ b/clang/test/CIR/Lowering/vec-cmp.cir
@@ -6,7 +6,7 @@
 
 cir.func @vec_cmp(%0: !cir.vector<!s16i x 16>, %1: !cir.vector<!s16i x 16>) -> () {
   %2 = cir.vec.cmp(lt, %0, %1) : !cir.vector<!s16i x 16>, !cir.vector<!cir.int<u, 1> x 16> 
-  %3 = cir.cast(bitcast, %2 : !cir.vector<!cir.int<u, 1> x 16>), !u16i
+  %3 = cir.cast bitcast %2 : !cir.vector<!cir.int<u, 1> x 16> -> !u16i
   cir.return
 }
     
diff --git a/clang/test/CIR/Transforms/if.cir b/clang/test/CIR/Transforms/if.cir
index 03848bf8d063..c86f087a677a 100644
--- a/clang/test/CIR/Transforms/if.cir
+++ b/clang/test/CIR/Transforms/if.cir
@@ -4,7 +4,7 @@
 
 module {
   cir.func @foo(%arg0: !s32i) -> !s32i {
-    %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
     cir.if %4 {
       %5 = cir.const #cir.int<1> : !s32i
       cir.return %5 : !s32i
@@ -15,7 +15,7 @@ module {
     cir.return %arg0 : !s32i
   }
 //      CHECK: cir.func @foo(%arg0: !s32i) -> !s32i {
-// CHECK-NEXT:   %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+// CHECK-NEXT:   %0 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
 // CHECK-NEXT:   cir.brcond %0 ^bb1, ^bb2
 // CHECK-NEXT: ^bb1:  // pred: ^bb0
 // CHECK-NEXT:   %1 = cir.const #cir.int<1> : !s32i
@@ -28,7 +28,7 @@ module {
 // CHECK-NEXT: }
 
   cir.func @onlyIf(%arg0: !s32i) -> !s32i {
-    %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+    %4 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
     cir.if %4 {
       %5 = cir.const #cir.int<1> : !s32i
       cir.return %5 : !s32i
@@ -36,7 +36,7 @@ module {
     cir.return %arg0 : !s32i
   }
 //      CHECK: cir.func @onlyIf(%arg0: !s32i) -> !s32i {
-// CHECK-NEXT:   %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+// CHECK-NEXT:   %0 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
 // CHECK-NEXT:   cir.brcond %0 ^bb1, ^bb2
 // CHECK-NEXT: ^bb1:  // pred: ^bb0
 // CHECK-NEXT:   %1 = cir.const #cir.int<1> : !s32i
diff --git a/clang/test/CIR/Transforms/lib-opt-find.cpp b/clang/test/CIR/Transforms/lib-opt-find.cpp
index 104f2a73f45d..1805ee0932c9 100644
--- a/clang/test/CIR/Transforms/lib-opt-find.cpp
+++ b/clang/test/CIR/Transforms/lib-opt-find.cpp
@@ -14,15 +14,15 @@ 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: %[[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: %[[pattern:.*]] = cir.cast(integral, %[[load_pattern:.*]] : !u8i), !s32i
+    // CHECK: %[[pattern:.*]] = cir.cast integral %[[load_pattern:.*]] : !u8i -> !s32i
 
     // CHECK-NOT: {{.*}} cir.call @_ZSt4findIPhhET_S1_S1_RKT0_(
     // CHECK: %[[array_size:.*]] = cir.const #cir.int<9> : !u64i
 
     // CHECK: %[[result_cast:.*]] = cir.libc.memchr(%[[cast_to_void]], %[[pattern]], %[[array_size]])
-    // CHECK: %[[memchr_res:.*]] = cir.cast(bitcast, %[[result_cast]] : !cir.ptr<!void>), !cir.ptr<!u8i>
+    // CHECK: %[[memchr_res:.*]] = cir.cast bitcast %[[result_cast]] : !cir.ptr<!void> -> !cir.ptr<!u8i>
     // CHECK: %[[nullptr:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!u8i>
     // CHECK: %[[cmp_res:.*]] = cir.cmp(eq, %[[nullptr]], %[[memchr_res]]) : !cir.ptr<!u8i>, !cir.bool
     // CHECK: cir.ternary(%[[cmp_res]], true {
@@ -47,15 +47,15 @@ unsigned char* test2(unsigned char* first, unsigned char* last, unsigned char v)
     // CHECK: %[[pattern_storage:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["v", init]
     // 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: %[[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: %[[pattern:.*]] = cir.cast(integral, %[[load_pattern:.*]] : !u8i), !s32i
+    // CHECK: %[[pattern:.*]] = cir.cast integral %[[load_pattern:.*]] : !u8i -> !s32i
 
     // CHECK-NOT: {{.*}} cir.call @_ZSt4findIPhhET_S1_S1_RKT0_(
     // CHECK: %[[array_size:.*]] = cir.ptr_diff(%[[last]], %[[first]]) : !cir.ptr<!u8i> -> !u64i
 
     // CHECK: %[[result_cast:.*]] = cir.libc.memchr(%[[cast_to_void]], %[[pattern]], %[[array_size]])
-    // CHECK: %[[memchr_res:.*]] = cir.cast(bitcast, %[[result_cast]] : !cir.ptr<!void>), !cir.ptr<!u8i>
+    // CHECK: %[[memchr_res:.*]] = cir.cast bitcast %[[result_cast]] : !cir.ptr<!void> -> !cir.ptr<!u8i>
     // CHECK: %[[nullptr:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!u8i>
     // CHECK: %[[cmp_res:.*]] = cir.cmp(eq, %[[nullptr]], %[[memchr_res]]) : !cir.ptr<!u8i>, !cir.bool
     // CHECK: cir.ternary(%[[cmp_res]], true {
diff --git a/clang/test/CIR/Transforms/mem2reg.c b/clang/test/CIR/Transforms/mem2reg.c
index ecfe43a883bb..c145b45f1614 100644
--- a/clang/test/CIR/Transforms/mem2reg.c
+++ b/clang/test/CIR/Transforms/mem2reg.c
@@ -181,8 +181,8 @@ void test_bitcast(size_t n) {
 // BEFORE:    cir.store{{.*}} %arg0, %0 : !u64i, !cir.ptr<!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>
+// BEFORE:    %4 = cir.cast bitcast %3 : !cir.ptr<!u8i> -> !cir.ptr<!void>
+// BEFORE:    %5 = cir.cast bitcast %4 : !cir.ptr<!void> -> !cir.ptr<!s32i>
 // BEFORE:    cir.store{{.*}} %5, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // BEFORE:    cir.return
 
diff --git a/clang/test/CIR/Transforms/merge-cleanups.cir b/clang/test/CIR/Transforms/merge-cleanups.cir
index a111fec0b0b4..f7888189aee4 100644
--- a/clang/test/CIR/Transforms/merge-cleanups.cir
+++ b/clang/test/CIR/Transforms/merge-cleanups.cir
@@ -125,7 +125,7 @@ module  {
   //       CHECK:  %[[ARG0:.+]]: !cir.ptr<!s32i>
   //       CHECK:  cir.return %[[ARG0]] : !cir.ptr<!s32i>
   cir.func @ptrbitcastfold(%arg0: !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {
-    %0 = cir.cast(bitcast, %arg0: !cir.ptr<!s32i>), !cir.ptr<!s32i>
+    %0 = cir.cast bitcast %arg0 : !cir.ptr<!s32i> -> !cir.ptr<!s32i>
     cir.return %0 : !cir.ptr<!s32i>
   }
 
@@ -134,7 +134,7 @@ module  {
   //       CHECK:  %[[ARG0:.+]]: !cir.ptr<!s32i, addrspace(target<2>)>
   //       CHECK:  cir.return %[[ARG0]] : !cir.ptr<!s32i, addrspace(target<2>)>
   cir.func @addrspacecastfold(%arg0: !cir.ptr<!s32i, addrspace(target<2>)>) -> !cir.ptr<!s32i, addrspace(target<2>)> {
-    %0 = cir.cast(address_space, %arg0: !cir.ptr<!s32i, addrspace(target<2>)>), !cir.ptr<!s32i, addrspace(target<2>)>
+    %0 = cir.cast address_space %arg0 : !cir.ptr<!s32i, addrspace(target<2>)> -> !cir.ptr<!s32i, addrspace(target<2>)>
     cir.return %0 : !cir.ptr<!s32i, addrspace(target<2>)>
   }
 
diff --git a/clang/test/CIR/Transforms/scf-prepare.cir b/clang/test/CIR/Transforms/scf-prepare.cir
index c86a051cf2cd..b4eb9633ba57 100644
--- a/clang/test/CIR/Transforms/scf-prepare.cir
+++ b/clang/test/CIR/Transforms/scf-prepare.cir
@@ -33,7 +33,7 @@ module {
         %4 = cir.const #cir.int<3> : !s32i
         %5 = cir.get_global @a : !cir.ptr<!cir.array<!s32i x 100>>
         %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
-        %7 = cir.cast(array_to_ptrdecay, %5 : !cir.ptr<!cir.array<!s32i x 100>>), !cir.ptr<!s32i>
+        %7 = cir.cast array_to_ptrdecay %5 : !cir.ptr<!cir.array<!s32i x 100>> -> !cir.ptr<!s32i>
         %8 = cir.ptr_stride %7, %6 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
         cir.store %4, %8 : !s32i, !cir.ptr<!s32i>
         cir.yield
@@ -71,7 +71,7 @@ module {
         %2 = cir.const #cir.int<3> : !s32i
         %3 = cir.get_global @a : !cir.ptr<!cir.array<!s32i x 100>>
         %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
-        %5 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!s32i x 100>>), !cir.ptr<!s32i>
+        %5 = cir.cast array_to_ptrdecay %3 : !cir.ptr<!cir.array<!s32i x 100>> -> !cir.ptr<!s32i>
         %6 = cir.ptr_stride %5, %4 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
         cir.store %2, %6 : !s32i, !cir.ptr<!s32i>
         cir.yield
@@ -120,7 +120,7 @@ module {
           %6 = cir.const #cir.int<3> : !s32i
           %7 = cir.get_global @a : !cir.ptr<!cir.array<!s32i x 100>>
           %8 = cir.load %2 : !cir.ptr<!s32i>, !s32i
-          %9 = cir.cast(array_to_ptrdecay, %7 : !cir.ptr<!cir.array<!s32i x 100>>), !cir.ptr<!s32i>
+          %9 = cir.cast array_to_ptrdecay %7 : !cir.ptr<!cir.array<!s32i x 100>> -> !cir.ptr<!s32i>
           %10 = cir.ptr_stride %9, %8 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
           cir.store %6, %10 : !s32i, !cir.ptr<!s32i>
         }
diff --git a/clang/test/CIR/Transforms/setjmp-longjmp-lower.c b/clang/test/CIR/Transforms/setjmp-longjmp-lower.c
index b76b3251cfae..883e3d6a0bf2 100644
--- a/clang/test/CIR/Transforms/setjmp-longjmp-lower.c
+++ b/clang/test/CIR/Transforms/setjmp-longjmp-lower.c
@@ -6,7 +6,7 @@ void test_setjmp(void *env) {
   // BEFORE-LOWERING-PREPARE-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>,
   // BEFORE-LOWERING-PREPARE-NEXT: cir.store [[ENV]], [[ENV_ALLOCA]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
   // BEFORE-LOWERING-PREPARE-NEXT: [[ENV_LOAD:%[0-9]+]] = cir.load align(8) [[ENV_ALLOCA]]
-  // BEFORE-LOWERING-PREPARE-NEXT: [[CAST:%[0-9]+]] = cir.cast(bitcast, [[ENV_LOAD]] : !cir.ptr<!void>), !cir.ptr<!cir.ptr<!void>>
+  // BEFORE-LOWERING-PREPARE-NEXT: [[CAST:%[0-9]+]] = cir.cast bitcast [[ENV_LOAD]] : !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
   // BEFORE-LOWERING-PREPARE-NEXT: [[ZERO:%[0-9]+]] = cir.const #cir.int<0>
   // BEFORE-LOWERING-PREPARE-NEXT: [[FA:%[0-9]+]] = cir.frame_address([[ZERO]])
   // BEFORE-LOWERING-PREPARE-NEXT: cir.store [[FA]], [[CAST]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
@@ -21,7 +21,7 @@ void test_setjmp(void *env) {
   // AFTER-LOWERING-PREPARE-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>,
   // AFTER-LOWERING-PREPARE-NEXT: cir.store [[ENV]], [[ENV_ALLOCA]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
   // AFTER-LOWERING-PREPARE-NEXT: [[ENV_LOAD:%[0-9]+]] = cir.load align(8) [[ENV_ALLOCA]]
-  // AFTER-LOWERING-PREPARE-NEXT: [[CAST:%[0-9]+]] = cir.cast(bitcast, [[ENV_LOAD]] : !cir.ptr<!void>), !cir.ptr<!cir.ptr<!void>>
+  // AFTER-LOWERING-PREPARE-NEXT: [[CAST:%[0-9]+]] = cir.cast bitcast [[ENV_LOAD]] : !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
   // AFTER-LOWERING-PREPARE-NEXT: [[ZERO:%[0-9]+]] = cir.const #cir.int<0>
   // AFTER-LOWERING-PREPARE-NEXT: [[FA:%[0-9]+]] = cir.frame_address([[ZERO]])
   // AFTER-LOWERING-PREPARE-NEXT: cir.store [[FA]], [[CAST]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
@@ -40,7 +40,7 @@ void test_setjmp2(void *env) {
   // BEFORE-LOWERING-PREPARE-NEXT: [[ENV_ALLOCA:%.*]] = cir.alloca
   // BEFORE-LOWERING-PREPARE-NEXT: cir.store [[ENV]], [[ENV_ALLOCA]]
   // BEFORE-LOWERING-PREPARE-NEXT: [[ENV_LOAD:%.*]] = cir.load align(8) [[ENV_ALLOCA]]
-  // BEFORE-LOWERING-PREPARE-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[ENV_LOAD]]
+  // BEFORE-LOWERING-PREPARE-NEXT: [[CAST:%.*]] = cir.cast bitcast [[ENV_LOAD]]
   // BEFORE-LOWERING-PREPARE-NEXT: cir.eh.setjmp [[CAST]] : (!cir.ptr<!cir.ptr<!void>>) -> !s32i
 
   // AFTER-LOWERING-PREPARE-LABEL: test_setjmp2
@@ -48,7 +48,7 @@ void test_setjmp2(void *env) {
   // AFTER-LOWERING-PREPARE-NEXT: [[ENV_ALLOCA:%.*]] = cir.alloca
   // AFTER-LOWERING-PREPARE-NEXT: cir.store [[ENV]], [[ENV_ALLOCA]]
   // AFTER-LOWERING-PREPARE-NEXT: [[ENV_LOAD:%.*]] = cir.load align(8) [[ENV_ALLOCA]]
-  // AFTER-LOWERING-PREPARE-NEXT: [[CAST:%.*]] = cir.cast(bitcast, [[ENV_LOAD]]
+  // AFTER-LOWERING-PREPARE-NEXT: [[CAST:%.*]] = cir.cast bitcast [[ENV_LOAD]]
   // AFTER-LOWERING-PREPARE-NEXT: cir.eh.setjmp [[CAST]] : (!cir.ptr<!cir.ptr<!void>>) -> !s32i
   _setjmp (env);
 }
diff --git a/clang/test/CIR/Transforms/simpl.c b/clang/test/CIR/Transforms/simpl.c
index 90d65d651369..b41c2b319ef7 100644
--- a/clang/test/CIR/Transforms/simpl.c
+++ b/clang/test/CIR/Transforms/simpl.c
@@ -19,17 +19,17 @@ int foo(int* ptr) {
 // BEFORE:  [[X0:%.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // BEFORE:  [[X1:%.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
 // BEFORE:  [[X2:%.*]] = cir.cmp(eq, [[X0]], [[X1]]) : !cir.ptr<!s32i>, !cir.bool
-// BEFORE:  [[BOOL_TO_INT:%.*]] = cir.cast(bool_to_int, [[X2]] : !cir.bool), !s32i
-// BEFORE:  [[X3:%.*]] = cir.cast(int_to_bool, [[BOOL_TO_INT]] : !s32i), !cir.bool
+// BEFORE:  [[BOOL_TO_INT:%.*]] = cir.cast bool_to_int [[X2]] : !cir.bool -> !s32i
+// BEFORE:  [[X3:%.*]] = cir.cast int_to_bool [[BOOL_TO_INT]] : !s32i -> !cir.bool
 // BEFORE:  [[X4:%.*]] = cir.unary(not, [[X3]]) : !cir.bool, !cir.bool
-// BEFORE:  [[X5:%.*]] = cir.cast(bool_to_int, [[X4]] : !cir.bool), !s32i
-// BEFORE:  [[X6:%.*]] = cir.cast(int_to_bool, [[X5]] : !s32i), !cir.bool
+// BEFORE:  [[X5:%.*]] = cir.cast bool_to_int [[X4]] : !cir.bool -> !s32i
+// BEFORE:  [[X6:%.*]] = cir.cast int_to_bool [[X5]] : !s32i -> !cir.bool
 // BEFORE:  [[X7:%.*]] = cir.unary(not, [[X6]]) : !cir.bool, !cir.bool
-// BEFORE:  [[X8:%.*]] = cir.cast(bool_to_int, [[X7]] : !cir.bool), !s32i
-// BEFORE:  [[X9:%.*]] = cir.cast(integral, [[X8]] : !s32i), !s64i
+// BEFORE:  [[X8:%.*]] = cir.cast bool_to_int [[X7]] : !cir.bool -> !s32i
+// BEFORE:  [[X9:%.*]] = cir.cast integral [[X8]] : !s32i -> !s64i
 // BEFORE:  [[X10:%.*]] = cir.const #cir.int<0> : !s32i
-// BEFORE:  [[X11:%.*]] = cir.cast(integral, [[X10]] : !s32i), !s64i
-// BEFORE:  [[X12:%.*]] = cir.cast(int_to_bool, [[X9]] : !s64i), !cir.bool
+// BEFORE:  [[X11:%.*]] = cir.cast integral [[X10]] : !s32i -> !s64i
+// BEFORE:  [[X12:%.*]] = cir.cast int_to_bool [[X9]] : !s64i -> !cir.bool
 // BEFORE:  cir.if [[X12]]
 
 // AFTER:   [[X0:%.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/Transforms/simpl.cir b/clang/test/CIR/Transforms/simpl.cir
index 77fa0e6f446a..34c27daeba34 100644
--- a/clang/test/CIR/Transforms/simpl.cir
+++ b/clang/test/CIR/Transforms/simpl.cir
@@ -12,38 +12,38 @@ module {
   // CHECK:     cir.return %arg0 : !cir.bool
 
   cir.func @cast1(%arg0: !cir.bool) -> !cir.bool {
-    %0 = cir.cast(bool_to_int, %arg0 : !cir.bool), !s32i
-    %1 = cir.cast(int_to_bool, %0 : !s32i), !cir.bool
+    %0 = cir.cast bool_to_int %arg0 : !cir.bool -> !s32i
+    %1 = cir.cast int_to_bool %0 : !s32i -> !cir.bool
     cir.return %1 : !cir.bool
   }
   // CHECK:  cir.func @cast1(%arg0: !cir.bool) -> !cir.bool
   // CHECK:     cir.return %arg0 : !cir.bool
 
   cir.func @cast2(%arg0: !s32i) -> !cir.bool {
-    %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
-    %1 = cir.cast(bool_to_int, %0 : !cir.bool), !s32i
-    %2 = cir.cast(integral, %1 : !s32i), !s64i
-    %3 = cir.cast(int_to_bool, %2 : !s64i), !cir.bool
+    %0 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
+    %1 = cir.cast bool_to_int %0 : !cir.bool -> !s32i
+    %2 = cir.cast integral %1 : !s32i -> !s64i
+    %3 = cir.cast int_to_bool %2 : !s64i -> !cir.bool
     cir.return %3 : !cir.bool
   }
   // CHECK:  cir.func @cast2(%arg0: !s32i) -> !cir.bool
-  // CHECK:    %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
+  // CHECK:    %0 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
   // CHECK:    cir.return %0 : !cir.bool
 
   cir.func @no_cast(%arg0: !s32i) -> !s64i {
-    %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
-    %1 = cir.cast(bool_to_int, %0 : !cir.bool), !s32i
-    %2 = cir.cast(integral, %1 : !s32i), !s64i
+    %0 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
+    %1 = cir.cast bool_to_int %0 : !cir.bool -> !s32i
+    %2 = cir.cast integral %1 : !s32i -> !s64i
     cir.return %2 : !s64i
   }
   // CHECK:  cir.func @no_cast(%arg0: !s32i) -> !s64i
-  // CHECK:    %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool
-  // CHECK:    %1 = cir.cast(bool_to_int, %0 : !cir.bool), !s32i
-  // CHECK:    %2 = cir.cast(integral, %1 : !s32i), !s64i
+  // CHECK:    %0 = cir.cast int_to_bool %arg0 : !s32i -> !cir.bool
+  // CHECK:    %1 = cir.cast bool_to_int %0 : !cir.bool -> !s32i
+  // CHECK:    %2 = cir.cast integral %1 : !s32i -> !s64i
   // CHECK:    cir.return %2 : !s64i
 
   cir.func @get_element(%arg0: !cir.ptr<!cir.array<!s32i x 5>>, %arg1: !s32i) -> !s32i {
-    %0 = cir.cast(array_to_ptrdecay, %arg0 : !cir.ptr<!cir.array<!s32i x 5>>), !cir.ptr<!s32i>
+    %0 = cir.cast array_to_ptrdecay %arg0 : !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!s32i>
     %1 = cir.ptr_stride %0, %arg1 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
     %2 = cir.load %1 : !cir.ptr<!s32i>, !s32i
     cir.return %2 : !s32i
diff --git a/clang/test/CIR/Transforms/switch.cir b/clang/test/CIR/Transforms/switch.cir
index 77ca59836f48..f88aea2c20bf 100644
--- a/clang/test/CIR/Transforms/switch.cir
+++ b/clang/test/CIR/Transforms/switch.cir
@@ -261,8 +261,8 @@ module {
 // CHECK-NEXT:     %[[RANGE:[0-9]+]] = cir.const #cir.int<99>
 // CHECK-NEXT:     %[[LOWER_BOUND:[0-9]+]] = cir.const #cir.int<1>
 // CHECK-NEXT:     %[[DIFF:[0-9]+]] = cir.binop(sub, %[[X]], %[[LOWER_BOUND]])
-// CHECK-NEXT:     %[[U_DIFF:[0-9]+]] = cir.cast(integral, %[[DIFF]] : !s32i), !u32i
-// CHECK-NEXT:     %[[U_RANGE:[0-9]+]] = cir.cast(integral, %[[RANGE]] : !s32i), !u32i
+// CHECK-NEXT:     %[[U_DIFF:[0-9]+]] = cir.cast integral %[[DIFF]] : !s32i -> !u32i
+// CHECK-NEXT:     %[[U_RANGE:[0-9]+]] = cir.cast integral %[[RANGE]] : !s32i -> !u32i
 // CHECK-NEXT:     %[[CMP_RESULT:[0-9]+]] = cir.cmp(le, %[[U_DIFF]], %[[U_RANGE]])
 // CHECK-NEXT:     cir.brcond %[[CMP_RESULT]] ^[[CASE_RANGE]], ^[[CASE_DEFAULT:bb[0-9]+]]
 // CHECK-NEXT:  ^[[CASE_DEFAULT]]: