[clang] [CIR] Add custom assembly format for alloca op to fix flag parsing (PR #198962)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Jun 3 21:10:49 PDT 2026
https://github.com/Andres-Salamanca updated https://github.com/llvm/llvm-project/pull/198962
>From f2ff0bcce1534b936f4e80235e0b51ac81845eb9 Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Wed, 20 May 2026 22:39:53 -0500
Subject: [PATCH 1/7] [CIR] Add custom assembly format for alloca op to fix
flag parsing
---
clang/include/clang/CIR/Dialect/IR/CIROps.td | 6 +--
clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 43 ++++++++++++++++++++
clang/test/CIR/IR/alloca.cir | 39 ++++++++++++++++++
3 files changed, 83 insertions(+), 5 deletions(-)
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index c4d08d5337031..fc15b4ae906dd 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -655,11 +655,7 @@ def CIR_AllocaOp : CIR_Op<"alloca", [
let assemblyFormat = [{
$allocaType `,` qualified(type($addr)) `,`
($dynAllocSize^ `:` type($dynAllocSize) `,`)?
- `[` $name
- (`,` `init` $init^)?
- (`,` `const` $constant^)?
- (`,` `cleanup_dest_slot` $cleanup_dest_slot^)?
- `]`
+ `[` custom<AllocaFlags>($name, $init, $constant, $cleanup_dest_slot) `]`
($annotations^)? attr-dict
}];
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index cf07fc4f0833a..7ae2d4fb24ddb 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -304,6 +304,49 @@ void cir::AllocaOp::build(mlir::OpBuilder &odsBuilder,
odsState.addTypes(addr);
}
+static ParseResult parseAllocaFlags(mlir::OpAsmParser &parser,
+ mlir::StringAttr &name,
+ mlir::UnitAttr &init,
+ mlir::UnitAttr &constant,
+ mlir::UnitAttr &cleanupDestSlot) {
+
+ std::string nameStr;
+ if (parser.parseString(&nameStr))
+ return failure();
+ name = parser.getBuilder().getStringAttr(nameStr);
+
+ if (failed(parser.parseOptionalComma()))
+ return success();
+
+ auto &builder = parser.getBuilder();
+ return parser.parseCommaSeparatedList([&]() -> ParseResult {
+ if (succeeded(parser.parseOptionalKeyword("init")))
+ init = builder.getUnitAttr();
+ else if (succeeded(parser.parseOptionalKeyword("const")))
+ constant = builder.getUnitAttr();
+ else if (succeeded(parser.parseOptionalKeyword("cleanup_dest_slot")))
+ cleanupDestSlot = builder.getUnitAttr();
+ else
+ return parser.emitError(
+ parser.getCurrentLocation(),
+ "expected 'init', 'const' or 'cleanup_dest_slot'");
+ return success();
+ });
+}
+
+static void printAllocaFlags(mlir::OpAsmPrinter &p, cir::AllocaOp op,
+ mlir::StringAttr name, mlir::UnitAttr init,
+ mlir::UnitAttr constant,
+ mlir::UnitAttr cleanupDestSlot) {
+ p << '"' << name.getValue() << '"';
+ if (init)
+ p << ", init";
+ if (constant)
+ p << ", const";
+ if (cleanupDestSlot)
+ p << ", cleanup_dest_slot";
+}
+
//===----------------------------------------------------------------------===//
// ArrayCtor & ArrayDtor
//===----------------------------------------------------------------------===//
diff --git a/clang/test/CIR/IR/alloca.cir b/clang/test/CIR/IR/alloca.cir
index d94da815f37a7..f8259c656eb37 100644
--- a/clang/test/CIR/IR/alloca.cir
+++ b/clang/test/CIR/IR/alloca.cir
@@ -3,6 +3,7 @@
!u64i = !cir.int<u, 64>
!u8i = !cir.int<u, 8>
+!s32i = !cir.int<s, 32>
!void = !cir.void
module {
cir.func dso_local @_Z11test_allocam(%arg0: !u64i) -> !cir.ptr<!void> {
@@ -29,4 +30,42 @@ module {
// CHECK: %5 = cir.load %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CHECK: cir.return %5 : !cir.ptr<!void>
// CHECK: }
+ // Parse tests for all flag combinations
+ cir.func dso_local @test_alloca_flags() {
+ // No flags
+ %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+
+ // init only
+ %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
+
+ // const only
+ %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", const] {alignment = 4 : i64}
+
+ // init + const
+ %3 = cir.alloca !s32i, !cir.ptr<!s32i>, ["d", init, const] {alignment = 4 : i64}
+
+ // cleanup_dest_slot only
+ %4 = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", cleanup_dest_slot] {alignment = 4 : i64}
+
+ // all flags
+ %6 = cir.alloca !s32i, !cir.ptr<!s32i>, ["f", init, const, cleanup_dest_slot] {alignment = 4 : i64}
+
+ // dynamic size, no flags
+ %sz = cir.const #cir.int<4> : !u64i
+ %7 = cir.alloca !u8i, !cir.ptr<!u8i>, %sz : !u64i, ["h"] {alignment = 16 : i64}
+
+ // dynamic size + init
+ %8 = cir.alloca !u8i, !cir.ptr<!u8i>, %sz : !u64i, ["i", init] {alignment = 16 : i64}
+
+ cir.return
+ }
+ // CHECK-LABEL: cir.func dso_local @test_alloca_flags
+ // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+ // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
+ // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["c", const] {alignment = 4 : i64}
+ // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["d", init, const] {alignment = 4 : i64}
+ // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["e", cleanup_dest_slot] {alignment = 4 : i64}
+ // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["f", init, const, cleanup_dest_slot] {alignment = 4 : i64}
+ // CHECK: cir.alloca !u8i, !cir.ptr<!u8i>, %{{.*}} : !u64i, ["h"] {alignment = 16 : i64}
+ // CHECK: cir.alloca !u8i, !cir.ptr<!u8i>, %{{.*}} : !u64i, ["i", init] {alignment = 16 : i64}
}
>From 6ad00d8ebe33bda6264c4b55d28a6139bba050c7 Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Tue, 26 May 2026 23:29:53 -0500
Subject: [PATCH 2/7] Update cir.alloca assembly format and tests
---
clang/include/clang/CIR/Dialect/IR/CIROps.td | 8 +-
clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 43 ----
.../CodeGen/abi-lower-after-unreachable.cpp | 4 +-
clang/test/CIR/CodeGen/abstract-cond.c | 20 +-
clang/test/CIR/CodeGen/agg-expr-lvalue.c | 14 +-
clang/test/CIR/CodeGen/agg-init-constexpr.cpp | 2 +-
.../CodeGen/amdgpu-call-addrspace-cast.cpp | 2 +-
clang/test/CIR/CodeGen/array-ctor.cpp | 16 +-
clang/test/CIR/CodeGen/array-dtor.cpp | 16 +-
.../CIR/CodeGen/array-init-loop-exprs.cpp | 16 +-
clang/test/CIR/CodeGen/array.cpp | 58 ++---
clang/test/CIR/CodeGen/assign-operator.cpp | 20 +-
clang/test/CIR/CodeGen/assume-attr.cpp | 6 +-
clang/test/CIR/CodeGen/atomic-thread-fence.c | 12 +-
clang/test/CIR/CodeGen/atomic.c | 20 +-
clang/test/CIR/CodeGen/base-to-derived.cpp | 6 +-
clang/test/CIR/CodeGen/basic.c | 22 +-
clang/test/CIR/CodeGen/basic.cpp | 32 +--
clang/test/CIR/CodeGen/binassign.c | 24 +-
clang/test/CIR/CodeGen/binop.cpp | 46 ++--
clang/test/CIR/CodeGen/bitfield-union.c | 2 +-
clang/test/CIR/CodeGen/bitfields.c | 14 +-
clang/test/CIR/CodeGen/bitfields.cpp | 6 +-
clang/test/CIR/CodeGen/bitfields_be.c | 4 +-
clang/test/CIR/CodeGen/builtins-x86.c | 4 +-
.../CodeGen/call-via-class-member-funcptr.cpp | 4 +-
clang/test/CIR/CodeGen/call.c | 2 +-
clang/test/CIR/CodeGen/call.cpp | 4 +-
clang/test/CIR/CodeGen/cast-cxx20.cpp | 16 +-
clang/test/CIR/CodeGen/cast.c | 2 +-
clang/test/CIR/CodeGen/cast.cpp | 6 +-
clang/test/CIR/CodeGen/choose-expr.cpp | 8 +-
clang/test/CIR/CodeGen/class.cpp | 8 +-
.../test/CIR/CodeGen/cleanup-automatic-eh.cpp | 4 +-
.../CIR/CodeGen/cleanup-conditional-eh.cpp | 30 +--
.../test/CIR/CodeGen/cleanup-conditional.cpp | 56 ++---
.../CIR/CodeGen/cleanup-scope-goto-out.cpp | 12 +-
.../CIR/CodeGen/cleanup-scope-goto-within.cpp | 4 +-
.../cleanup-scope-tmp-with-exception.cpp | 4 +-
clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp | 4 +-
.../CIR/CodeGen/cleanup-throwing-dtor.cpp | 4 +-
clang/test/CIR/CodeGen/cleanup.cpp | 34 +--
clang/test/CIR/CodeGen/cmp.cpp | 28 +--
clang/test/CIR/CodeGen/comma.c | 8 +-
clang/test/CIR/CodeGen/complex-atomic-cast.c | 4 +-
clang/test/CIR/CodeGen/complex-builtins.cpp | 16 +-
clang/test/CIR/CodeGen/complex-cast.cpp | 4 +-
.../CodeGen/complex-compound-assignment.cpp | 58 ++---
clang/test/CIR/CodeGen/complex-mul-div.cpp | 90 +++----
clang/test/CIR/CodeGen/complex-plus-minus.cpp | 32 +--
clang/test/CIR/CodeGen/complex-unary.cpp | 88 +++----
clang/test/CIR/CodeGen/complex.cpp | 222 +++++++++---------
clang/test/CIR/CodeGen/compound_literal.cpp | 14 +-
.../CIR/CodeGen/concept-specialization.cpp | 2 +-
clang/test/CIR/CodeGen/constant-expr.cpp | 6 +-
clang/test/CIR/CodeGen/copy-constructor.cpp | 4 +-
clang/test/CIR/CodeGen/coro-task.cpp | 66 +++---
clang/test/CIR/CodeGen/count-of.c | 8 +-
.../test/CIR/CodeGen/ctor-alias-prev-decl.cpp | 4 +-
clang/test/CIR/CodeGen/ctor-alias.cpp | 8 +-
clang/test/CIR/CodeGen/ctor-null-init.cpp | 6 +-
clang/test/CIR/CodeGen/ctor-try-body.cpp | 4 +-
clang/test/CIR/CodeGen/ctor.cpp | 82 +++----
.../CIR/CodeGen/cxx-conversion-operators.cpp | 14 +-
clang/test/CIR/CodeGen/cxx-default-init.cpp | 4 +-
.../CodeGen/cxx-rewritten-binary-operator.cpp | 6 +-
clang/test/CIR/CodeGen/cxx-traits.cpp | 14 +-
.../CodeGen/cxx23-explicit-object-member.cpp | 2 +-
clang/test/CIR/CodeGen/defaultarg.cpp | 4 +-
clang/test/CIR/CodeGen/deferred-fn-defs.cpp | 2 +-
.../CodeGen/delegating-ctor-exceptions.cpp | 2 +-
clang/test/CIR/CodeGen/delegating-ctor.cpp | 24 +-
.../CodeGen/delete-array-throwing-dtor.cpp | 2 +-
.../CIR/CodeGen/delete-array-unsized-dtor.cpp | 2 +-
clang/test/CIR/CodeGen/delete-array.cpp | 2 +-
clang/test/CIR/CodeGen/delete-destroying.cpp | 6 +-
clang/test/CIR/CodeGen/delete.cpp | 2 +-
clang/test/CIR/CodeGen/derived-to-base.cpp | 8 +-
clang/test/CIR/CodeGen/destructors.cpp | 6 +-
.../test/CIR/CodeGen/dtor-alias-prev-decl.cpp | 4 +-
clang/test/CIR/CodeGen/dtor-alias.cpp | 6 +-
clang/test/CIR/CodeGen/dtors.cpp | 28 +--
clang/test/CIR/CodeGen/embed-expr.c | 6 +-
clang/test/CIR/CodeGen/empty-union.c | 4 +-
clang/test/CIR/CodeGen/empty-union.cpp | 4 +-
clang/test/CIR/CodeGen/fixed-point-literal.c | 24 +-
clang/test/CIR/CodeGen/forrange.cpp | 40 ++--
clang/test/CIR/CodeGen/generic-selection.c | 4 +-
clang/test/CIR/CodeGen/global-array-dtor.cpp | 2 +-
clang/test/CIR/CodeGen/global-init.cpp | 2 +-
clang/test/CIR/CodeGen/gnu-null.cpp | 4 +-
clang/test/CIR/CodeGen/gnu-ptr-math.c | 32 +--
clang/test/CIR/CodeGen/if.cpp | 4 +-
clang/test/CIR/CodeGen/implicit-return-zero.c | 4 +-
.../CIR/CodeGen/implicit-value-init-expr.cpp | 4 +-
clang/test/CIR/CodeGen/inherited-ctors.cpp | 14 +-
clang/test/CIR/CodeGen/init-list-lvalue.cpp | 16 +-
.../CodeGen/initializer-list-two-pointers.cpp | 4 +-
clang/test/CIR/CodeGen/inline-asm.c | 108 ++++-----
clang/test/CIR/CodeGen/inline-cxx-func.cpp | 6 +-
clang/test/CIR/CodeGen/instantiate-init.cpp | 6 +-
clang/test/CIR/CodeGen/kr-func-promote.c | 4 +-
clang/test/CIR/CodeGen/label-values.c | 10 +-
clang/test/CIR/CodeGen/label.c | 2 +-
.../CodeGen/lambda-decomp-decl-captures.cpp | 24 +-
clang/test/CIR/CodeGen/lambda-dtor-field.cpp | 14 +-
.../lambda-static-invoker-agg-return.cpp | 6 +-
.../CIR/CodeGen/lambda-static-invoker.cpp | 42 ++--
clang/test/CIR/CodeGen/lambda.cpp | 48 ++--
clang/test/CIR/CodeGen/launder.cpp | 16 +-
clang/test/CIR/CodeGen/local-vars.cpp | 48 ++--
.../test/CIR/CodeGen/long-double-inc-dec.cpp | 16 +-
clang/test/CIR/CodeGen/loop.cpp | 30 +--
clang/test/CIR/CodeGen/mem-expr-fn.cpp | 4 +-
clang/test/CIR/CodeGen/member-functions.cpp | 10 +-
clang/test/CIR/CodeGen/multi-vtable.cpp | 2 +-
.../CIR/CodeGen/new-delete-deactivation.cpp | 16 +-
clang/test/CIR/CodeGen/new-delete.cpp | 46 ++--
clang/test/CIR/CodeGen/new.cpp | 38 +--
clang/test/CIR/CodeGen/no-odr-use.cpp | 2 +-
clang/test/CIR/CodeGen/noexcept.cpp | 6 +-
.../CIR/CodeGen/non-scalar-lval-return.cpp | 4 +-
.../CIR/CodeGen/non-type-template-param.cpp | 2 +-
clang/test/CIR/CodeGen/nonzeroinit-struct.cpp | 8 +-
clang/test/CIR/CodeGen/nrvo.cpp | 10 +-
clang/test/CIR/CodeGen/nullptr-init.cpp | 6 +-
clang/test/CIR/CodeGen/opaque.c | 6 +-
clang/test/CIR/CodeGen/opaque.cpp | 32 +--
.../CIR/CodeGen/openmp_default_simd_align.c | 2 +-
clang/test/CIR/CodeGen/pack-indexing.cpp | 16 +-
clang/test/CIR/CodeGen/paren-init-list-eh.cpp | 2 +-
clang/test/CIR/CodeGen/paren-init-list.cpp | 4 +-
.../test/CIR/CodeGen/paren-list-agg-init.cpp | 92 ++++----
.../CIR/CodeGen/partial-array-cleanup.cpp | 46 ++--
clang/test/CIR/CodeGen/pass-object-size.c | 4 +-
clang/test/CIR/CodeGen/placement-new.cpp | 2 +-
.../CodeGen/pointer-to-data-member-cast.cpp | 4 +-
.../CIR/CodeGen/pointer-to-data-member.cpp | 52 ++--
.../CodeGen/pointer-to-member-func-cast.cpp | 8 +-
.../CIR/CodeGen/pointer-to-member-func.cpp | 12 +-
clang/test/CIR/CodeGen/replace-global.cpp | 2 +-
clang/test/CIR/CodeGen/requires-expr.cpp | 4 +-
clang/test/CIR/CodeGen/self-assign.c | 2 +-
clang/test/CIR/CodeGen/size-of-vla.cpp | 24 +-
clang/test/CIR/CodeGen/source-loc.cpp | 10 +-
clang/test/CIR/CodeGen/statement-exprs.c | 30 +--
.../CIR/CodeGen/static-local-arm-guard.cpp | 2 +-
clang/test/CIR/CodeGen/static-local.cpp | 34 +--
clang/test/CIR/CodeGen/stmt-expr.cpp | 14 +-
clang/test/CIR/CodeGen/string-literals.cpp | 2 +-
clang/test/CIR/CodeGen/struct-init.cpp | 20 +-
clang/test/CIR/CodeGen/struct.c | 14 +-
clang/test/CIR/CodeGen/struct.cpp | 44 ++--
clang/test/CIR/CodeGen/switch.cpp | 10 +-
clang/test/CIR/CodeGen/switch_flat_op.cpp | 6 +-
.../test/CIR/CodeGen/temp-param-obj-decl.cpp | 4 +-
.../temporary-materialization-adjust.cpp | 14 +-
.../CIR/CodeGen/temporary-materialization.cpp | 10 +-
clang/test/CIR/CodeGen/ternary-throw.cpp | 44 ++--
clang/test/CIR/CodeGen/ternary.cpp | 38 +--
.../test/CIR/CodeGen/thread-local-in-func.cpp | 16 +-
clang/test/CIR/CodeGen/three-way-cmp.cpp | 16 +-
clang/test/CIR/CodeGen/throws.cpp | 12 +-
clang/test/CIR/CodeGen/thunks.cpp | 6 +-
.../CIR/CodeGen/trivial-ctor-const-init.cpp | 2 +-
.../CodeGen/try-catch-all-with-cleanup.cpp | 10 +-
.../CodeGen/try-catch-non-trivial-copy.cpp | 8 +-
clang/test/CIR/CodeGen/try-catch.cpp | 32 +--
.../CIR/CodeGen/try-no-throwing-calls.cpp | 2 +-
clang/test/CIR/CodeGen/typedef.c | 2 +-
clang/test/CIR/CodeGen/unary.cpp | 42 ++--
clang/test/CIR/CodeGen/union-agg-init.c | 4 +-
clang/test/CIR/CodeGen/union-agg-init.cpp | 4 +-
clang/test/CIR/CodeGen/union.c | 12 +-
clang/test/CIR/CodeGen/var-arg-aggregate.c | 6 +-
clang/test/CIR/CodeGen/var_arg.c | 18 +-
.../CIR/CodeGen/variable-decomposition.cpp | 4 +-
clang/test/CIR/CodeGen/vbase.cpp | 6 +-
clang/test/CIR/CodeGen/vector-ext-element.cpp | 62 ++---
clang/test/CIR/CodeGen/vector-ext.cpp | 144 ++++++------
clang/test/CIR/CodeGen/vector.cpp | 146 ++++++------
.../CIR/CodeGen/virtual-destructor-calls.cpp | 4 +-
.../test/CIR/CodeGen/virtual-fn-calls-eh.cpp | 4 +-
.../CIR/CodeGen/virtual-function-calls.cpp | 6 +-
clang/test/CIR/CodeGen/vla.c | 58 ++---
clang/test/CIR/CodeGen/vtt.cpp | 16 +-
.../CodeGenBuiltins/builtin-address-of.cpp | 4 +-
.../CIR/CodeGenBuiltins/builtin-bcopy.cpp | 8 +-
.../CIR/CodeGenBuiltins/builtin-bit-cast.cpp | 2 +-
.../test/CIR/CodeGenBuiltins/builtin-call.cpp | 6 +-
.../CIR/CodeGenBuiltins/builtin-constant-p.c | 20 +-
.../CIR/CodeGenBuiltins/builtin-fcmp-sse.c | 24 +-
.../CIR/CodeGenBuiltins/builtin-offset-of.cpp | 16 +-
.../CIR/CodeGenBuiltins/builtin-prefetch.c | 2 +-
.../CIR/CodeGenBuiltins/builtin-printf.cpp | 4 +-
.../CodeGenBuiltins/builtin-setjmp-longjmp.c | 4 +-
.../CIR/CodeGenBuiltins/builtin-signbit.c | 16 +-
clang/test/CIR/CodeGenCUDA/address-spaces.cu | 2 +-
clang/test/CIR/CodeGenCUDA/device-printf.cu | 2 +-
clang/test/CIR/CodeGenCUDA/kernel-call.cu | 24 +-
clang/test/CIR/CodeGenCXX/global-refs.cpp | 2 +-
clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp | 2 +-
.../new-array-init-list-non-trivial-dtor.cpp | 4 +-
clang/test/CIR/CodeGenCXX/new-array-init.cpp | 12 +-
.../simple-reinterpret-const-cast.cpp | 4 +-
clang/test/CIR/CodeGenCXX/sizeof-pack.cpp | 8 +-
clang/test/CIR/CodeGenCXX/typeid.cpp | 2 +-
.../CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp | 4 +-
.../test/CIR/CodeGenCXX/x86_64-arguments.cpp | 4 +-
.../CIR/CodeGenOpenACC/atomic-capture.cpp | 50 ++--
clang/test/CIR/CodeGenOpenACC/atomic-read.cpp | 6 +-
.../test/CIR/CodeGenOpenACC/atomic-update.cpp | 24 +-
.../test/CIR/CodeGenOpenACC/atomic-write.cpp | 8 +-
clang/test/CIR/CodeGenOpenACC/cache.c | 4 +-
clang/test/CIR/CodeGenOpenACC/combined-copy.c | 22 +-
.../test/CIR/CodeGenOpenACC/combined-copy.cpp | 4 +-
.../combined-copyin-copyout-create.c | 6 +-
.../combined-firstprivate-clause.cpp | 62 ++---
.../combined-private-clause.cpp | 52 ++--
.../combined-reduction-clause-default-ops.cpp | 108 ++++-----
.../combined-reduction-clause-float.cpp | 72 +++---
.../combined-reduction-clause-inline-ops.cpp | 152 ++++++------
.../combined-reduction-clause-int.cpp | 108 ++++-----
.../combined-reduction-clause-outline-ops.cpp | 152 ++++++------
clang/test/CIR/CodeGenOpenACC/combined.cpp | 8 +-
clang/test/CIR/CodeGenOpenACC/compute-copy.c | 20 +-
.../test/CIR/CodeGenOpenACC/compute-copy.cpp | 4 +-
.../compute-copyin-copyout-create.c | 6 +-
.../compute-firstprivate-clause-templates.cpp | 16 +-
.../compute-firstprivate-clause.c | 30 +--
.../compute-firstprivate-clause.cpp | 62 ++---
.../compute-private-clause-templates.cpp | 16 +-
.../CodeGenOpenACC/compute-private-clause.c | 24 +-
.../CodeGenOpenACC/compute-private-clause.cpp | 52 ++--
.../compute-reduction-clause-default-ops.c | 108 ++++-----
.../compute-reduction-clause-default-ops.cpp | 108 ++++-----
.../compute-reduction-clause-float.c | 72 +++---
.../compute-reduction-clause-float.cpp | 72 +++---
.../compute-reduction-clause-inline-ops.cpp | 152 ++++++------
.../compute-reduction-clause-int.c | 108 ++++-----
.../compute-reduction-clause-int.cpp | 108 ++++-----
.../compute-reduction-clause-outline-ops.cpp | 152 ++++++------
.../compute-reduction-clause-unsigned-int.c | 108 ++++-----
.../data-copy-copyin-copyout-create.c | 4 +-
clang/test/CIR/CodeGenOpenACC/data.c | 4 +-
.../test/CIR/CodeGenOpenACC/declare-copy.cpp | 40 ++--
.../CIR/CodeGenOpenACC/declare-copyin.cpp | 40 ++--
.../CIR/CodeGenOpenACC/declare-copyout.cpp | 40 ++--
.../CIR/CodeGenOpenACC/declare-create.cpp | 40 ++--
.../CIR/CodeGenOpenACC/declare-deviceptr.cpp | 28 +--
.../CodeGenOpenACC/declare-deviceresident.cpp | 40 ++--
.../test/CIR/CodeGenOpenACC/declare-link.cpp | 4 +-
.../CIR/CodeGenOpenACC/declare-present.cpp | 40 ++--
clang/test/CIR/CodeGenOpenACC/enter-data.c | 4 +-
clang/test/CIR/CodeGenOpenACC/exit-data.c | 4 +-
.../firstprivate-clause-recipes.cpp | 62 ++---
clang/test/CIR/CodeGenOpenACC/host_data.c | 8 +-
clang/test/CIR/CodeGenOpenACC/init.c | 2 +-
clang/test/CIR/CodeGenOpenACC/kernels.c | 6 +-
.../CodeGenOpenACC/loop-private-clause.cpp | 52 ++--
.../loop-reduction-clause-default-ops.cpp | 108 ++++-----
.../loop-reduction-clause-float.cpp | 72 +++---
.../loop-reduction-clause-inline-ops.cpp | 152 ++++++------
.../loop-reduction-clause-int.cpp | 108 ++++-----
.../loop-reduction-clause-outline-ops.cpp | 152 ++++++------
clang/test/CIR/CodeGenOpenACC/loop.cpp | 8 +-
clang/test/CIR/CodeGenOpenACC/parallel.c | 6 +-
.../private-clause-array-recipes-CtorDtor.cpp | 62 ++---
.../private-clause-array-recipes-NoOps.cpp | 38 +--
.../private-clause-array-recipes-int.cpp | 14 +-
...-clause-pointer-array-recipes-CtorDtor.cpp | 208 ++++++++--------
...ate-clause-pointer-array-recipes-NoOps.cpp | 164 ++++++-------
...ivate-clause-pointer-array-recipes-int.cpp | 120 +++++-----
...rivate-clause-pointer-recipes-CtorDtor.cpp | 82 +++----
.../private-clause-pointer-recipes-NoOps.cpp | 70 +++---
.../private-clause-pointer-recipes-int.cpp | 58 ++---
.../reduction-clause-recipes.cpp | 80 +++----
clang/test/CIR/CodeGenOpenACC/serial.c | 6 +-
clang/test/CIR/CodeGenOpenACC/set.c | 2 +-
clang/test/CIR/CodeGenOpenACC/shutdown.c | 2 +-
clang/test/CIR/CodeGenOpenACC/update.c | 4 +-
clang/test/CIR/CodeGenOpenACC/wait.c | 2 +-
clang/test/CIR/CodeGenOpenCL/as_type.cl | 12 +-
clang/test/CIR/CodeGenOpenMP/omp-llvmir.c | 6 +-
clang/test/CIR/CodeGenOpenMP/parallel.c | 4 +-
clang/test/CIR/IR/alloca.cir | 44 ++--
clang/test/CIR/IR/array-ctor.cir | 4 +-
clang/test/CIR/IR/array-dtor.cir | 4 +-
clang/test/CIR/IR/array.cir | 12 +-
clang/test/CIR/IR/binassign.cir | 16 +-
clang/test/CIR/IR/bitfield_info.cir | 2 +-
clang/test/CIR/IR/cmp.cir | 60 ++---
clang/test/CIR/IR/construct-catch-param.cir | 4 +-
clang/test/CIR/IR/func-attrs.cir | 16 +-
clang/test/CIR/IR/func.cir | 2 +-
clang/test/CIR/IR/indirect-br.cir | 8 +-
clang/test/CIR/IR/inline-asm.cir | 6 +-
clang/test/CIR/IR/invalid-complex.cir | 6 +-
.../CIR/IR/invalid-construct-catch-param.cir | 14 +-
clang/test/CIR/IR/invalid-data-member.cir | 4 +-
clang/test/CIR/IR/invalid-throw.cir | 2 +-
clang/test/CIR/IR/invalid-try-catch.cir | 2 +-
clang/test/CIR/IR/method-attr.cir | 12 +-
clang/test/CIR/IR/resume-flat.cir | 8 +-
clang/test/CIR/IR/struct.cir | 8 +-
clang/test/CIR/IR/throw.cir | 12 +-
clang/test/CIR/IR/unary.cir | 8 +-
clang/test/CIR/IR/vector.cir | 68 +++---
clang/test/CIR/IR/vtable-addrpt.cir | 2 +-
clang/test/CIR/IR/vtt-addrpoint.cir | 6 +-
clang/test/CIR/Lowering/address-space.cir | 6 +-
clang/test/CIR/Lowering/alloca.cir | 2 +-
clang/test/CIR/Lowering/binop-bool.cir | 4 +-
clang/test/CIR/Lowering/binop-fp.cir | 12 +-
clang/test/CIR/Lowering/binop-signed-int.cir | 6 +-
.../test/CIR/Lowering/binop-unsigned-int.cir | 6 +-
clang/test/CIR/Lowering/cast.cir | 22 +-
clang/test/CIR/Lowering/goto.cir | 4 +-
clang/test/CIR/Lowering/inline-asm.cir | 6 +-
clang/test/CIR/Lowering/omp-target-map.cir | 2 +-
clang/test/CIR/Lowering/resume-flat.cir | 4 +-
clang/test/CIR/Lowering/switch.cir | 8 +-
clang/test/CIR/Lowering/vtt-addrpoint.cir | 6 +-
clang/test/CIR/Transforms/canonicalize.cir | 4 +-
.../CIR/Transforms/complex-create-fold.cir | 8 +-
.../test/CIR/Transforms/complex-imag-fold.cir | 4 +-
.../test/CIR/Transforms/complex-real-fold.cir | 4 +-
...h-abi-lowering-construct-catch-invalid.cir | 6 +-
.../eh-abi-lowering-construct-catch.cir | 6 +-
.../Transforms/eh-abi-lowering-itanium.cir | 10 +-
.../Transforms/flatten-cleanup-scope-eh.cir | 60 ++---
.../flatten-cleanup-scope-multi-exit.cir | 136 +++++------
.../flatten-cleanup-scope-simple.cir | 68 +++---
.../flatten-throwing-in-cleanup.cir | 10 +-
clang/test/CIR/Transforms/flatten-try-op.cir | 28 +--
clang/test/CIR/Transforms/goto_solver.cir | 6 +-
clang/test/CIR/Transforms/hoist-allocas.cir | 12 +-
clang/test/CIR/Transforms/mem2reg.cir | 4 +-
clang/test/CIR/Transforms/scope.cir | 8 +-
clang/test/CIR/Transforms/switch-fold.cir | 12 +-
clang/test/CIR/Transforms/switch.cir | 18 +-
clang/test/CIR/Transforms/ternary-fold.cir | 4 +-
clang/test/CIR/Transforms/ternary.cir | 8 +-
.../CIR/Transforms/vector-extract-fold.cir | 8 +-
clang/test/CIR/func-simple.cpp | 16 +-
345 files changed, 4237 insertions(+), 4276 deletions(-)
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index fc15b4ae906dd..d32cd5177b3ac 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -653,9 +653,13 @@ def CIR_AllocaOp : CIR_Op<"alloca", [
}];
let assemblyFormat = [{
- $allocaType `,` qualified(type($addr)) `,`
+ $name
+ `align` `(` $alignment `)`
+ oilist( `init` $init
+ | `const` $constant
+ | `cleanup_dest_slot` $cleanup_dest_slot)
($dynAllocSize^ `:` type($dynAllocSize) `,`)?
- `[` custom<AllocaFlags>($name, $init, $constant, $cleanup_dest_slot) `]`
+ $allocaType `->` qualified(type($addr))
($annotations^)? attr-dict
}];
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index 7ae2d4fb24ddb..cf07fc4f0833a 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -304,49 +304,6 @@ void cir::AllocaOp::build(mlir::OpBuilder &odsBuilder,
odsState.addTypes(addr);
}
-static ParseResult parseAllocaFlags(mlir::OpAsmParser &parser,
- mlir::StringAttr &name,
- mlir::UnitAttr &init,
- mlir::UnitAttr &constant,
- mlir::UnitAttr &cleanupDestSlot) {
-
- std::string nameStr;
- if (parser.parseString(&nameStr))
- return failure();
- name = parser.getBuilder().getStringAttr(nameStr);
-
- if (failed(parser.parseOptionalComma()))
- return success();
-
- auto &builder = parser.getBuilder();
- return parser.parseCommaSeparatedList([&]() -> ParseResult {
- if (succeeded(parser.parseOptionalKeyword("init")))
- init = builder.getUnitAttr();
- else if (succeeded(parser.parseOptionalKeyword("const")))
- constant = builder.getUnitAttr();
- else if (succeeded(parser.parseOptionalKeyword("cleanup_dest_slot")))
- cleanupDestSlot = builder.getUnitAttr();
- else
- return parser.emitError(
- parser.getCurrentLocation(),
- "expected 'init', 'const' or 'cleanup_dest_slot'");
- return success();
- });
-}
-
-static void printAllocaFlags(mlir::OpAsmPrinter &p, cir::AllocaOp op,
- mlir::StringAttr name, mlir::UnitAttr init,
- mlir::UnitAttr constant,
- mlir::UnitAttr cleanupDestSlot) {
- p << '"' << name.getValue() << '"';
- if (init)
- p << ", init";
- if (constant)
- p << ", const";
- if (cleanupDestSlot)
- p << ", cleanup_dest_slot";
-}
-
//===----------------------------------------------------------------------===//
// ArrayCtor & ArrayDtor
//===----------------------------------------------------------------------===//
diff --git a/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp b/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp
index 92f8be1ca97ff..eb048974adba7 100644
--- a/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp
+++ b/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp
@@ -18,8 +18,8 @@ void untransformed_after_unreachable(Base2 &ref, PMFTy pmf) {
(badcast.*pmf)();
// CIR-LABEL: cir.func {{.*}}@_Z31untransformed_after_unreachableR5Base2M7DerivedFvvE
-// CIR: %[[PMF:.*]] = cir.alloca !{{.*}} ["pmf", init]
-// CIR: %[[DERIVED:.*]] = cir.alloca !rec_Derived
+// CIR: %[[PMF:.*]] = cir.alloca "pmf" {{.*}} init
+// CIR: %[[DERIVED:.*]] = cir.alloca {{.*}} !rec_Derived
// CIR: cir.load %{{.*}} : !cir.ptr<!cir.ptr<!rec_Base2>>, !cir.ptr<!rec_Base2>
// CIR-NEXT: cir.call @__cxa_bad_cast() {noreturn} : () -> ()
// CIR-NEXT: cir.unreachable
diff --git a/clang/test/CIR/CodeGen/abstract-cond.c b/clang/test/CIR/CodeGen/abstract-cond.c
index fc02b4df1fffc..11d2ee90211ef 100644
--- a/clang/test/CIR/CodeGen/abstract-cond.c
+++ b/clang/test/CIR/CodeGen/abstract-cond.c
@@ -12,10 +12,10 @@ int test_agg_cond(int a0, struct s6 a1, struct s6 a2) {
}
// CIR: cir.func {{.*}} @test_agg_cond
-// CIR: %[[A0:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a0"
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1"
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2"
-// CIR: %[[TMP:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["ref.tmp0"]
+// CIR: %[[A0:.*]] = cir.alloca "a0" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: %[[LOAD_A0:.*]] = cir.load{{.*}} %[[A0]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[COND:.*]] = cir.cast int_to_bool %[[LOAD_A0]] : !s32i -> !cir.bool
// CIR: cir.if %[[COND]] {
@@ -60,16 +60,16 @@ int test_stmt_expr(int flag, struct s6 a1, struct s6 a2) {
}
// CIR: cir.func {{.*}} @test_stmt_expr
-// CIR: %[[FLAG:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["flag"
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1"
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2"
-// CIR: %[[TMP:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["ref.tmp0"]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: %[[LOAD_FLAG:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[COND:.*]] = cir.cast int_to_bool %[[LOAD_FLAG]] : !s32i -> !cir.bool
// CIR: cir.if %[[COND]] {
-// CIR: %[[STMT_TMP:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["tmp"]
+// CIR: %[[STMT_TMP:.*]] = cir.alloca "tmp" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: cir.scope {
-// CIR: %[[T:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["t", init]
+// CIR: %[[T:.*]] = cir.alloca "t" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: cir.copy %[[A1]] to %[[T]] : !cir.ptr<!rec_s6>
// CIR: cir.call @foo() : () -> ()
// CIR: cir.copy %[[T]] to %[[TMP]] : !cir.ptr<!rec_s6>
diff --git a/clang/test/CIR/CodeGen/agg-expr-lvalue.c b/clang/test/CIR/CodeGen/agg-expr-lvalue.c
index 1986491dab75d..5e5639f8f32af 100644
--- a/clang/test/CIR/CodeGen/agg-expr-lvalue.c
+++ b/clang/test/CIR/CodeGen/agg-expr-lvalue.c
@@ -27,8 +27,8 @@ void test_member_in_array(void) {
// LLVM-DAG: @[[MATRIX_CONST:.*]] = private constant [2 x [6 x i8]] {{.*}}
// CIR-LABEL: cir.func{{.*}} @test_member_in_array
-// CIR: %[[LINE:.*]] = cir.alloca !rec_Line{{.*}}, ["line", init]
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_Point x 1>{{.*}}, ["arr", init]
+// CIR: %[[LINE:.*]] = cir.alloca "line" {{.*}} init !rec_Line{{.*}}
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>{{.*}}
// CIR: cir.get_global @[[LINE_CONST]]
// CIR: cir.copy
// CIR: %[[MEMBER:.*]] = cir.get_member %[[LINE]][0] {name = "start"}
@@ -55,8 +55,8 @@ void test_member_arrow_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_member_arrow_in_array
-// CIR: %[[PTR:.*]] = cir.alloca !cir.ptr<!rec_Line>{{.*}}, ["line_ptr"]
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_Point x 1>{{.*}}, ["arr", init]
+// CIR: %[[PTR:.*]] = cir.alloca "line_ptr" {{.*}} !cir.ptr<!rec_Line>{{.*}}
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>{{.*}}
// CIR: %[[LOADED:.*]] = cir.load{{.*}}%[[PTR]]
// CIR: %[[MEMBER:.*]] = cir.get_member %[[LOADED]][0] {name = "start"}
// CIR: cir.copy
@@ -82,8 +82,8 @@ void test_deref_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_deref_in_array
-// CIR: %[[PTR:.*]] = cir.alloca !cir.ptr<!rec_Point>{{.*}}, ["ptr"]
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_Point x 1>{{.*}}, ["arr", init]
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} !cir.ptr<!rec_Point>{{.*}}
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>{{.*}}
// CIR: %[[LOADED:.*]] = cir.load{{.*}}%[[PTR]]
// CIR: cir.copy
@@ -105,7 +105,7 @@ void test_string_array_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_string_array_in_array
-// CIR: %[[MATRIX:.*]] = cir.alloca !cir.array<!cir.array<!s8i x 6> x 2>, {{.*}}, ["matrix", init]
+// CIR: %[[MATRIX:.*]] = cir.alloca "matrix" {{.*}} init !cir.array<!cir.array<!s8i x 6> x 2> -> {{.*}}
// CIR: %[[CONST:.*]] = cir.get_global @[[MATRIX_CONST]] : !cir.ptr<!cir.array<!cir.array<!s8i x 6> x 2>>
// CIR: cir.copy %[[CONST]] to %[[MATRIX]]
diff --git a/clang/test/CIR/CodeGen/agg-init-constexpr.cpp b/clang/test/CIR/CodeGen/agg-init-constexpr.cpp
index 8cef9ef33bda5..713f6cc481b60 100644
--- a/clang/test/CIR/CodeGen/agg-init-constexpr.cpp
+++ b/clang/test/CIR/CodeGen/agg-init-constexpr.cpp
@@ -20,7 +20,7 @@ extern "C" void construct() {
}
// CIR-LABEL: construct()
-// CIR-NEXT: %[[WC_ALLOCA:.*]] = cir.alloca !rec_WithCtor
+// CIR-NEXT: %[[WC_ALLOCA:.*]] = cir.alloca {{.*}} !rec_WithCtor
// CIR-NEXT: %[[CONST_VAL:.*]] = cir.const #cir.const_record<{#cir.int<4> : !s32i, #cir.int<10> : !s64i, #cir.const_record<{#cir.int<5> : !s32i}> : !rec_HasVal}>
// CIR-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[WC_ALLOCA]]
// CIR-NEXT: cir.store{{.*}}%[[CONST_VAL]], %[[BITCAST]]
diff --git a/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp b/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp
index 3217addeca800..334e246ba5731 100644
--- a/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp
+++ b/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp
@@ -28,7 +28,7 @@ void call_with_global_ptr() {
}
// CIR-LABEL: cir.func{{.*}} @_Z19call_with_local_ptrv()
-// CIR: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i, target_address_space(5)>
+// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i, target_address_space(5)>
// CIR: %[[CAST:.*]] = cir.cast address_space %[[ALLOCA]] : !cir.ptr<!s32i, target_address_space(5)> -> !cir.ptr<!s32i>
// CIR: cir.call @_Z9takes_ptrPi(%[[CAST]])
diff --git a/clang/test/CIR/CodeGen/array-ctor.cpp b/clang/test/CIR/CodeGen/array-ctor.cpp
index 4a3a4f51db13b..fcdfdb75537c4 100644
--- a/clang/test/CIR/CodeGen/array-ctor.cpp
+++ b/clang/test/CIR/CodeGen/array-ctor.cpp
@@ -15,7 +15,7 @@ void foo() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z3foov()
-// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s", init]
+// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
// CIR-BEFORE-LPP: cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 42>> {
// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -24,11 +24,11 @@ void foo() {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z3foov()
-// CIR: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s", init]
+// CIR: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 42>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST42]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[DECAY]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
@@ -84,12 +84,12 @@ void zero_sized() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z10zero_sizedv()
-// CIR-BEFORE-LPP: cir.alloca !cir.array<!rec_S x 0>, !cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
+// CIR-BEFORE-LPP: cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-BEFORE-LPP-NOT: cir.array.ctor
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func {{.*}} @_Z10zero_sizedv()
-// CIR: cir.alloca !cir.array<!rec_S x 0>, !cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
+// CIR: cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-NOT: cir.do
// CIR-NOT: cir.call @_ZN1SC1Ev
// CIR: cir.return
@@ -109,7 +109,7 @@ void multi_dimensional() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca !cir.array<!cir.array<!rec_S x 5> x 3>, !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>, ["s", init]
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} init !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR-BEFORE-LPP: %[[FLAT:.*]] = cir.cast bitcast %[[S]] : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>> -> !cir.ptr<!cir.array<!rec_S x 15>>
// CIR-BEFORE-LPP: cir.array.ctor %[[FLAT]] : !cir.ptr<!cir.array<!rec_S x 15>> {
// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
@@ -118,11 +118,11 @@ void multi_dimensional() {
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR: %[[S:.*]] = cir.alloca !cir.array<!cir.array<!rec_S x 5> x 3>, !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>, ["s", init]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR: %[[CONST15:.*]] = cir.const #cir.int<15> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay {{.*}} : !cir.ptr<!cir.array<!rec_S x 15>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST15]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[DECAY]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/array-dtor.cpp b/clang/test/CIR/CodeGen/array-dtor.cpp
index 5bfe9ac897cb7..b52e41cd8acdb 100644
--- a/clang/test/CIR/CodeGen/array-dtor.cpp
+++ b/clang/test/CIR/CodeGen/array-dtor.cpp
@@ -15,7 +15,7 @@ void test_cleanup_array() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z18test_cleanup_arrayv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s"]
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
// CIR-BEFORE-LPP: cir.array.dtor %[[S]] : !cir.ptr<!cir.array<!rec_S x 42>> {
// CIR-BEFORE-LPP: ^bb0(%arg0: !cir.ptr<!rec_S>
// CIR-BEFORE-LPP: cir.call @_ZN1SD1Ev(%arg0) nothrow : (!cir.ptr<!rec_S> {{.*}}) -> ()
@@ -23,11 +23,11 @@ void test_cleanup_array() {
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z18test_cleanup_arrayv()
-// CIR: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s"]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[S]] : !cir.ptr<!cir.array<!rec_S x 42>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST42]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[END_PTR]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
@@ -82,12 +82,12 @@ void test_cleanup_zero_length_array() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z30test_cleanup_zero_length_arrayv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 0>, !cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-BEFORE-LPP-NOT: cir.array.dtor
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z30test_cleanup_zero_length_arrayv()
-// CIR: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 0>, !cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-NOT: cir.do
// CIR-NOT: cir.call @_ZN1SD1Ev
// CIR: cir.return
@@ -107,7 +107,7 @@ void multi_dimensional() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca !cir.array<!cir.array<!rec_S x 5> x 3>, !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>, ["s"]
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR-BEFORE-LPP: %[[FLAT:.*]] = cir.cast bitcast %[[S]] : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>> -> !cir.ptr<!cir.array<!rec_S x 15>>
// CIR-BEFORE-LPP: cir.array.dtor %[[FLAT]] : !cir.ptr<!cir.array<!rec_S x 15>> {
// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
@@ -116,12 +116,12 @@ void multi_dimensional() {
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR: %[[S:.*]] = cir.alloca !cir.array<!cir.array<!rec_S x 5> x 3>, !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>, ["s"]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR: %[[FLAT:.*]] = cir.cast bitcast %[[S]] : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>> -> !cir.ptr<!cir.array<!rec_S x 15>>
// CIR: %[[CONST15:.*]] = cir.const #cir.int<15> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[FLAT]] : !cir.ptr<!cir.array<!rec_S x 15>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST15]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[END_PTR]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp b/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp
index 59a7a62c85a0d..48b478da06840 100644
--- a/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp
+++ b/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp
@@ -18,9 +18,9 @@ struct HasNonTrivialArray {
};
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN18HasNonTrivialArrayC2ERKS_({{.*}}) special_member<#cir.cxx_ctor<!rec_HasNonTrivialArray, copy>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasNonTrivialArray>, !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>, ["this", init]
-// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasNonTrivialArray>, !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>, ["", init, const]
-// CIR: %[[ITR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NonTrivial>, !cir.ptr<!cir.ptr<!rec_NonTrivial>>, ["arrayinit.temp"]
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasNonTrivialArray> -> !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>
+// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_HasNonTrivialArray> -> !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>
+// CIR: %[[ITR_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_NonTrivial> -> !cir.ptr<!cir.ptr<!rec_NonTrivial>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>, !cir.ptr<!rec_HasNonTrivialArray>
// CIR: %[[THIS_ARR:.*]] = cir.get_member %[[THIS_LOAD]][0] {name = "arr"} : !cir.ptr<!rec_HasNonTrivialArray> -> !cir.ptr<!cir.array<!rec_NonTrivial x 3>>
// CIR: %[[RHS_LOAD:.*]] = cir.load %[[RHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>, !cir.ptr<!rec_HasNonTrivialArray>
@@ -138,11 +138,11 @@ struct HasMultiDimArray {
};
// CIR-LABEL: cir.func {{.*}}@_ZN16HasMultiDimArrayC2ERKS_({{.*}}) special_member<#cir.cxx_ctor<!rec_HasMultiDimArray, copy>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasMultiDimArray>, !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>, ["this", init]
-// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasMultiDimArray>, !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>, ["", init, const]
-// CIR: %[[ITR1_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>>, !cir.ptr<!cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>>>, ["arrayinit.temp"]
-// CIR: %[[ITR2_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_NonTrivial x 4>>, !cir.ptr<!cir.ptr<!cir.array<!rec_NonTrivial x 4>>>, ["arrayinit.temp"]
-// CIR: %[[ITR3_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NonTrivial>, !cir.ptr<!cir.ptr<!rec_NonTrivial>>, ["arrayinit.temp"] {alignment = 8 : i64}
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasMultiDimArray> -> !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>
+// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_HasMultiDimArray> -> !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>
+// CIR: %[[ITR1_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>>>
+// CIR: %[[ITR2_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!cir.array<!rec_NonTrivial x 4>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NonTrivial x 4>>>
+// CIR: %[[ITR3_ALLOCA:.*]] = cir.alloca "arrayinit.temp" align(8) !cir.ptr<!rec_NonTrivial> -> !cir.ptr<!cir.ptr<!rec_NonTrivial>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>, !cir.ptr<!rec_HasMultiDimArray>
// CIR: %[[THIS_ARR:.*]] = cir.get_member %[[THIS_LOAD]][0] {name = "arr"} : !cir.ptr<!rec_HasMultiDimArray> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3> x 2>>
// CIR: %[[RHS_LOAD:.*]] = cir.load %[[RHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>, !cir.ptr<!rec_HasMultiDimArray>
diff --git a/clang/test/CIR/CodeGen/array.cpp b/clang/test/CIR/CodeGen/array.cpp
index 396ae4387c873..e673dcf743ef9 100644
--- a/clang/test/CIR/CodeGen/array.cpp
+++ b/clang/test/CIR/CodeGen/array.cpp
@@ -144,9 +144,9 @@ void func() {
int e2 = arr[1];
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["arr"]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
-// CIR: %[[INIT_2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e2", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT_2:.*]] = cir.alloca "e2" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[ELE_PTR:.*]] = cir.get_element %[[ARR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[ELE_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -181,7 +181,7 @@ void func2() {
int arr[2] = {5};
}
-// CIR: %[[ARR2:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
+// CIR: %[[ARR2:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC2_ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR2]] : !cir.ptr<!cir.array<!s32i x 2>>
@@ -199,9 +199,9 @@ void func3() {
int e = arr[idx];
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
-// CIR: %[[IDX:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["idx", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC3_ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[IDX_V:.*]] = cir.const #cir.int<1> : !s32i
@@ -240,8 +240,8 @@ void func4() {
int e = arr[1][0];
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.array<!s32i x 1> x 2>, !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>, ["arr", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.array<!s32i x 1> x 2> -> !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC4_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
@@ -272,7 +272,7 @@ void func5() {
int arr[2][1] = {{5}};
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.array<!s32i x 1> x 2>, !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>, ["arr", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.array<!s32i x 1> x 2> -> !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC5_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
@@ -288,8 +288,8 @@ void func6() {
int arr[2] = { x, 5 };
}
-// CIR: %[[VAR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
+// CIR: %[[VAR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[V:.*]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store{{.*}} %[[V]], %[[VAR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[ARR_PTR:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
@@ -322,7 +322,7 @@ void func7() {
int* arr[1] = {};
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.ptr<!s32i> x 1>, !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>, ["arr", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.ptr<!s32i> x 1> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC7_ARR]] : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
@@ -339,9 +339,9 @@ void func8(int arr[10]) {
}
// CIR: cir.func{{.*}} @_Z5func8Pi(%[[ARG:.*]]: !cir.ptr<!s32i>
-// CIR: %[[ARR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arr", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
-// CIR: %[[INIT_2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e2", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT_2:.*]] = cir.alloca "e2" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -386,8 +386,8 @@ void func9(int arr[10][5]) {
}
// CIR: cir.func{{.*}} @_Z5func9PA5_i(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>
-// CIR: %[[ARR:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, ["arr", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<2> : !s64i
// CIR: %[[IDX_1:.*]] = cir.const #cir.int<1> : !s64i
@@ -421,8 +421,8 @@ void func10(int *a) {
}
// CIR: cir.func{{.*}} @_Z6func10Pi(%[[ARG:.*]]: !cir.ptr<!s32i>
-// CIR: %[[ARR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["a", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<5> : !s64i
// CIR: %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -449,7 +449,7 @@ void func10(int *a) {
void func11() { int _Complex a[4]; }
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.complex<!s32i> x 4>, !cir.ptr<!cir.array<!cir.complex<!s32i> x 4>>, ["a"]
+// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} !cir.array<!cir.complex<!s32i> x 4> -> !cir.ptr<!cir.array<!cir.complex<!s32i> x 4>>
// LLVM: %[[ARR:.*]] = alloca [4 x { i32, i32 }], i64 1, align 16
@@ -464,7 +464,7 @@ void func12() {
Point a[4];
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_Point x 4>, !cir.ptr<!cir.array<!rec_Point x 4>>, ["a"]
+// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} !cir.array<!rec_Point x 4> -> !cir.ptr<!cir.array<!rec_Point x 4>>
// LLVM: %[[ARR:.*]] = alloca [4 x %struct.Point], i64 1, align 16
@@ -474,7 +474,7 @@ void array_with_complex_elements() {
_Complex float arr[2] = {{1.1f, 2.2f}, {3.3f, 4.4f}};
}
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!cir.complex<!cir.float> x 2>, !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>, ["arr", init]
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.complex<!cir.float> x 2> -> !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[COMPLEX_ARR]] : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR_ADDR]] : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
@@ -489,9 +489,9 @@ void boolean_index_access(int x) {
int n = arr[x > 4];
}
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr", init]
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR: %[[CMP:.*]] = cir.cmp gt %[[X]], %[[FOUR]] : !s32i
@@ -529,9 +529,9 @@ void bitint_index_access(_BitInt(7) i) {
// being used as a subscript.
// CIR: cir.func{{.*}} @_Z19bitint_index_accessDB7_
-// CIR: %[[I_ADDR:.*]] = cir.alloca !cir.int<s, 7, bitint>, !cir.ptr<!cir.int<s, 7, bitint>>, ["i", init]
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["arr", init]
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !cir.int<s, 7, bitint> -> !cir.ptr<!cir.int<s, 7, bitint>>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[I:.*]] = cir.load{{.*}} %[[I_ADDR]] : !cir.ptr<!cir.int<s, 7, bitint>>, !cir.int<s, 7, bitint>
// CIR: %[[IDX:.*]] = cir.cast integral %[[I]] : !cir.int<s, 7, bitint> -> !s64i
// CIR: %[[ELE:.*]] = cir.get_element %[[ARR_ADDR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/assign-operator.cpp b/clang/test/CIR/CodeGen/assign-operator.cpp
index 050b5db22e335..bf88e8ff0a269 100644
--- a/clang/test/CIR/CodeGen/assign-operator.cpp
+++ b/clang/test/CIR/CodeGen/assign-operator.cpp
@@ -15,7 +15,7 @@ void a() {
// CIR: cir.func {{.*}} @_ZN1xaSEi(!cir.ptr<!rec_x> {{.*}}, !s32i {{.*}})
// CIR: cir.func{{.*}} @_Z1av()
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_x, !cir.ptr<!rec_x>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_x -> !cir.ptr<!rec_x>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[RET:.*]] = cir.call @_ZN1xaSEi(%[[A_ADDR]], %[[ONE]]) : (!cir.ptr<!rec_x> {{.*}}, !s32i {{.*}}) -> (!s32i {llvm.noundef})
@@ -27,8 +27,8 @@ void f(int i, int j) {
}
// CIR: cir.func{{.*}} @_Z1fii(%arg0: !s32i {{.*}}, %arg1: !s32i {{.*}})
-// CIR: %[[I_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
-// CIR: %[[J_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["j", init]
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[J_ADDR:.*]] = cir.alloca "j" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %arg0, %[[I_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %arg1, %[[J_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[SEVENTEEN:.*]] = cir.const #cir.int<17> : !s32i
@@ -63,9 +63,9 @@ void copy_c(C &c1, C &c2) {
// Implicit assignment operator for C.
// CIR: cir.func {{.*}} @_ZN1CaSERKS_(%arg0: !cir.ptr<!rec_C> {{.*}}, %arg1: !cir.ptr<!rec_C> {{.*}}) -> (!cir.ptr<!rec_C>{{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init]
-// CIR: %[[ARG1_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["", init, const]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["__retval"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[ARG1_ADDR:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: cir.store %arg0, %[[THIS_ADDR]]
// CIR: cir.store %arg1, %[[ARG1_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -111,8 +111,8 @@ void copy_c(C &c1, C &c2) {
// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}} %[[B1]], ptr {{.*}} %[[B2]], i64 64, i1 false)
// CIR: cir.func{{.*}} @_Z6copy_cR1CS0_(%arg0: !cir.ptr<!rec_C> {{.*}}, %arg1: !cir.ptr<!rec_C> {{.*}})
-// CIR: %[[C1_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["c1", init, const]
-// CIR: %[[C2_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["c2", init, const]
+// CIR: %[[C1_ADDR:.*]] = cir.alloca "c1" {{.*}} init const !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[C2_ADDR:.*]] = cir.alloca "c2" {{.*}} init const !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: cir.store %arg0, %[[C1_ADDR]]
// CIR: cir.store %arg1, %[[C2_ADDR]]
// CIR: %[[C2_LOAD:.*]] = cir.load{{.*}} %[[C2_ADDR]]
@@ -135,8 +135,8 @@ void copy_ref_to_ref(E &e1, E &e2) {
// The call to e2.get_d_ref() must occur before the call to e1.get_d_ref().
// CIR: cir.func{{.*}} @_Z15copy_ref_to_refR1ES0_(%arg0: !cir.ptr<!rec_E> {{.*}}, %arg1: !cir.ptr<!rec_E> {{.*}})
-// CIR: %[[E1_ADDR:.*]] = cir.alloca !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>, ["e1", init, const]
-// CIR: %[[E2_ADDR:.*]] = cir.alloca !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>, ["e2", init, const]
+// CIR: %[[E1_ADDR:.*]] = cir.alloca "e1" {{.*}} init const !cir.ptr<!rec_E> -> !cir.ptr<!cir.ptr<!rec_E>>
+// CIR: %[[E2_ADDR:.*]] = cir.alloca "e2" {{.*}} init const !cir.ptr<!rec_E> -> !cir.ptr<!cir.ptr<!rec_E>>
// CIR: cir.store %arg0, %[[E1_ADDR]] : !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>
// CIR: cir.store %arg1, %[[E2_ADDR]] : !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>
// CIR: %[[E2:.*]] = cir.load %[[E2_ADDR]]
diff --git a/clang/test/CIR/CodeGen/assume-attr.cpp b/clang/test/CIR/CodeGen/assume-attr.cpp
index 5d621d07736b9..0e166b925c105 100644
--- a/clang/test/CIR/CodeGen/assume-attr.cpp
+++ b/clang/test/CIR/CodeGen/assume-attr.cpp
@@ -16,9 +16,9 @@ void usage(int i, int j) {
// CIR: cir.func{{.*}}@_Z5usageii
// BOTH: define{{.*}}@_Z5usageii
- // CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
- // CIR: %[[J:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["j", init]
- // CIR: %[[LOCAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["local", init, const]
+ // CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[J:.*]] = cir.alloca "j" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} init const !s32i -> !cir.ptr<!s32i>
//
// BOTH: %[[I:.*]] = alloca i32
// BOTH: %[[J:.*]] = alloca i32
diff --git a/clang/test/CIR/CodeGen/atomic-thread-fence.c b/clang/test/CIR/CodeGen/atomic-thread-fence.c
index bca91a61d8d24..00b4820ed061d 100644
--- a/clang/test/CIR/CodeGen/atomic-thread-fence.c
+++ b/clang/test/CIR/CodeGen/atomic-thread-fence.c
@@ -46,7 +46,7 @@ void modifyWithThreadFence(DataPtr d) {
__atomic_thread_fence(__ATOMIC_SEQ_CST);
d->value = 42;
// CIR-LABEL: @modifyWithThreadFence
- // CIR: %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
// CIR: cir.atomic.fence syncscope(system) seq_cst
// CIR: %[[VAL_42:.*]] = cir.const #cir.int<42> : !s32i
// CIR: %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
@@ -75,7 +75,7 @@ void modifyWithSignalFence(DataPtr d) {
__atomic_signal_fence(__ATOMIC_SEQ_CST);
d->value = 24;
// CIR-LABEL: @modifyWithSignalFence
- // CIR: %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
// CIR: cir.atomic.fence syncscope(single_thread) seq_cst
// CIR: %[[VAL_42:.*]] = cir.const #cir.int<24> : !s32i
// CIR: %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
@@ -104,8 +104,8 @@ void loadWithThreadFence(DataPtr d) {
__atomic_thread_fence(__ATOMIC_SEQ_CST);
__atomic_load_n(&d->ptr, __ATOMIC_SEQ_CST);
// CIR-LABEL: @loadWithThreadFence
- // CIR: %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["atomic-temp"] {alignment = 8 : i64}
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// 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>>
@@ -141,8 +141,8 @@ void loadWithSignalFence(DataPtr d) {
__atomic_signal_fence(__ATOMIC_SEQ_CST);
__atomic_load_n(&d->ptr, __ATOMIC_SEQ_CST);
// CIR-LABEL: @loadWithSignalFence
- // CIR: %[[DATA:.*]] = cir.alloca !cir.ptr<!rec_Data>, !cir.ptr<!cir.ptr<!rec_Data>>, ["d", init] {alignment = 8 : i64}
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["atomic-temp"] {alignment = 8 : i64}
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// 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>>
diff --git a/clang/test/CIR/CodeGen/atomic.c b/clang/test/CIR/CodeGen/atomic.c
index e4f3fe82310a4..7c6bb5490d64b 100644
--- a/clang/test/CIR/CodeGen/atomic.c
+++ b/clang/test/CIR/CodeGen/atomic.c
@@ -21,7 +21,7 @@ void f1(void) {
}
// CIR-LABEL: @f1
-// CIR: %[[SLOT:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+// CIR: %[[SLOT:.+]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[INIT:.+]] = cir.const #cir.int<42> : !s32i
// CIR-NEXT: cir.store align(4) %[[INIT]], %[[SLOT]] : !s32i, !cir.ptr<!s32i>
// CIR: }
@@ -42,7 +42,7 @@ void f2(void) {
}
// CIR-LABEL: @f2
-// CIR: %[[SLOT:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"] {alignment = 4 : i64}
+// CIR: %[[SLOT:.+]] = cir.alloca "x" align(4) !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[INIT:.+]] = cir.const #cir.int<42> : !s32i
// CIR-NEXT: cir.store align(4) %[[INIT]], %[[SLOT]] : !s32i, !cir.ptr<!s32i>
// CIR: }
@@ -288,7 +288,7 @@ void c11_atomic_cmpxchg_strong(_Atomic(int) *ptr, int *expected, int desired, in
// CIR-LABEL: @c11_atomic_cmpxchg_strong
// LLVM-LABEL: @c11_atomic_cmpxchg_strong
// OGCG-LABEL: @c11_atomic_cmpxchg_strong
- // CIR: %[[FAILURE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["failure", init]
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
__c11_atomic_compare_exchange_strong(ptr, expected, desired,
__ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
@@ -370,7 +370,7 @@ void c11_atomic_cmpxchg_weak(_Atomic(int) *ptr, int *expected, int desired, int
// CIR-LABEL: @c11_atomic_cmpxchg_weak
// LLVM-LABEL: @c11_atomic_cmpxchg_weak
// OGCG-LABEL: @c11_atomic_cmpxchg_weak
- // CIR: %[[FAILURE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["failure", init]
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
__c11_atomic_compare_exchange_weak(ptr, expected, desired,
__ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
@@ -452,7 +452,7 @@ void atomic_cmpxchg(int *ptr, int *expected, int *desired, int failure) {
// CIR-LABEL: @atomic_cmpxchg
// LLVM-LABEL: @atomic_cmpxchg
// OGCG-LABEL: @atomic_cmpxchg
- // CIR: %[[FAILURE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["failure", init]
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
__atomic_compare_exchange(ptr, expected, desired, /*weak=*/0, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[OLD:.+]], %[[SUCCESS:.+]] = cir.atomic.cmpxchg success(seq_cst) failure(acquire) syncscope(system) %{{.+}}, %{{.+}}, %{{.+}} align(4) : (!cir.ptr<!s32i>, !s32i, !s32i) -> (!s32i, !cir.bool)
@@ -633,7 +633,7 @@ void atomic_cmpxchg_n(int *ptr, int *expected, int desired, int failure) {
// CIR-LABEL: @atomic_cmpxchg_n
// LLVM-LABEL: @atomic_cmpxchg_n
// OGCG-LABEL: @atomic_cmpxchg_n
- // CIR: %[[FAILURE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["failure", init]
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
__atomic_compare_exchange_n(ptr, expected, desired, /*weak=*/0, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[OLD:.+]], %[[SUCCESS:.+]] = cir.atomic.cmpxchg success(seq_cst) failure(acquire) syncscope(system) %{{.+}}, %{{.+}}, %{{.+}} align(4) : (!cir.ptr<!s32i>, !s32i, !s32i) -> (!s32i, !cir.bool)
@@ -3281,8 +3281,8 @@ void atomic_cmpxchg_maybe_weak(int *ptr, int *expected, int *desired, int failur
// CIR-LABEL: @atomic_cmpxchg_maybe_weak
// LLVM-LABEL: @atomic_cmpxchg_maybe_weak
// OGCG-LABEL: @atomic_cmpxchg_maybe_weak
- // CIR: %[[FAILURE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["failure", init]
- // CIR: %[[WEAK:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["weak", init]
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[WEAK:.*]] = cir.alloca "weak" {{.*}} init !s32i -> !cir.ptr<!s32i>
__atomic_compare_exchange(ptr, expected, desired, weak, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[WEAK_LOAD:.*]] = cir.load{{.*}}%[[WEAK]]
@@ -3459,8 +3459,8 @@ void atomic_cmpxchg_n_maybe_weak(int *ptr, int *expected, int desired, int failu
// CIR-LABEL: @atomic_cmpxchg_n_maybe_weak
// LLVM-LABEL: @atomic_cmpxchg_n_maybe_weak
// OGCG-LABEL: @atomic_cmpxchg_n_maybe_weak
- // CIR: %[[FAILURE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["failure", init]
- // CIR: %[[WEAK:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["weak", init]
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[WEAK:.*]] = cir.alloca "weak" {{.*}} init !s32i -> !cir.ptr<!s32i>
__atomic_compare_exchange_n(ptr, expected, desired, weak, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[WEAK_LOAD:.*]] = cir.load{{.*}}%[[WEAK]]
diff --git a/clang/test/CIR/CodeGen/base-to-derived.cpp b/clang/test/CIR/CodeGen/base-to-derived.cpp
index 147b0b897e674..067aef7ce6d59 100644
--- a/clang/test/CIR/CodeGen/base-to-derived.cpp
+++ b/clang/test/CIR/CodeGen/base-to-derived.cpp
@@ -24,7 +24,7 @@ X *castAtoX(A *a) {
}
// CIR: cir.func {{.*}} @_Z8castAtoXP1A(%[[ARG0:.*]]: !cir.ptr<!rec_A> {{.*}})
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
// CIR: cir.store %[[ARG0]], %[[A_ADDR]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[X:.*]] = cir.derived_class_addr %[[A]] : !cir.ptr<!rec_A> [0] -> !cir.ptr<!rec_X>
@@ -46,7 +46,7 @@ X *castBtoX(B *b) {
}
// CIR: cir.func {{.*}} @_Z8castBtoXP1B(%[[ARG0:.*]]: !cir.ptr<!rec_B> {{.*}})
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["b", init]
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CIR: cir.store %[[ARG0]], %[[B_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] : !cir.ptr<!rec_B> [4] -> !cir.ptr<!rec_X>
@@ -79,7 +79,7 @@ X &castBReftoXRef(B &b) {
}
// CIR: cir.func {{.*}} @_Z14castBReftoXRefR1B(%[[ARG0:.*]]: !cir.ptr<!rec_B> {{.*}})
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["b", init, const]
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init const !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CIR: cir.store %[[ARG0]], %[[B_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] : !cir.ptr<!rec_B> nonnull [4] -> !cir.ptr<!rec_X>
diff --git a/clang/test/CIR/CodeGen/basic.c b/clang/test/CIR/CodeGen/basic.c
index ac49fd2d253b0..01482cc952558 100644
--- a/clang/test/CIR/CodeGen/basic.c
+++ b/clang/test/CIR/CodeGen/basic.c
@@ -35,8 +35,8 @@ int f1(int i) {
}
// CIR: cir.func{{.*}} @f1(%arg0: !s32i {llvm.noundef} loc({{.*}})) -> !s32i
-// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
-// CIR-NEXT: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %arg0, %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: %[[I_IGNORED:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -65,7 +65,7 @@ int f1(int i) {
int f2(void) { return 3; }
// CIR: cir.func{{.*}} @f2() -> !s32i
-// CIR-NEXT: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[THREE]], %[[RV]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: %[[R:.*]] = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
@@ -87,8 +87,8 @@ int f3(void) {
}
// CIR: cir.func{{.*}} @f3() -> !s32i
-// CIR-NEXT: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[THREE]], %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -172,7 +172,7 @@ int f6(void) {
}
// CIR: cir.func{{.*}} @f6() -> !s32i
-// CIR-NEXT: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[GV_PTR:.*]] = cir.get_global @gv : !cir.ptr<!s32i>
// CIR-NEXT: %[[GV:.*]] = cir.load{{.*}} %[[GV_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: cir.store{{.*}} %[[GV]], %[[RV]] : !s32i, !cir.ptr<!s32i>
@@ -196,9 +196,9 @@ int f7(int a, int b, int c) {
}
// CIR: cir.func{{.*}} @f7
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[C_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[C_PTR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[C:.*]] = cir.load{{.*}} %[[C_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -232,7 +232,7 @@ int f8(int *p) {
}
// CIR: cir.func{{.*}} @f8
-// CIR: %[[P_PTR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p", init]
+// CIR: %[[P_PTR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: %[[P:.*]] = cir.load deref{{.*}} %[[P_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[TWO]], %[[P]] : !s32i, !cir.ptr<!s32i>
@@ -270,7 +270,7 @@ void f9() {}
void f10(int arg0, ...) {}
// CIR: cir.func{{.*}} @f10(%[[ARG0:.*]]: !s32i {llvm.noundef} loc({{.*}}), ...)
-// CIR-NEXT: %[[ARG0_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["arg0", init] {alignment = 4 : i64}
+// CIR-NEXT: %[[ARG0_PTR:.*]] = cir.alloca "arg0" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[ARG0]], %[[ARG0_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.return
diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp
index d1758b6667a7f..f92fcb26e13e2 100644
--- a/clang/test/CIR/CodeGen/basic.cpp
+++ b/clang/test/CIR/CodeGen/basic.cpp
@@ -32,8 +32,8 @@ int f1() {
}
// CHECK: cir.func{{.*}} @_Z2f1v() -> (!s32i {{.*}})
-// CHECK: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CHECK: %[[I_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"] {alignment = 4 : i64}
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[I_PTR:.*]] = cir.alloca "i" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
// CHECK: cir.store{{.*}} %[[I]], %[[RV]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[R:.*]] = cir.load{{.*}} %[[RV]] : !cir.ptr<!s32i>, !s32i
@@ -45,8 +45,8 @@ int f2() {
}
// CHECK: cir.func{{.*}} @_Z2f2v() -> (!s32i {{.*}})
-// CHECK: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CHECK: %[[I_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init, const] {alignment = 4 : i64}
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[I_PTR:.*]] = cir.alloca "i" align(4) init const !s32i -> !cir.ptr<!s32i>
// CHECK: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CHECK: cir.store{{.*}} %[[TWO]], %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -59,8 +59,8 @@ int f3(int i) {
}
// CHECK: cir.func{{.*}} @_Z2f3i(%[[ARG:.*]]: !s32i {{.*}} loc({{.*}})) -> (!s32i {{.*}})
-// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
-// CHECK: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: cir.store{{.*}} %[[ARG]], %[[ARG_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[ARG_VAL:.*]] = cir.load{{.*}} %[[ARG_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CHECK: cir.store{{.*}} %[[ARG_VAL]], %[[RV]] : !s32i, !cir.ptr<!s32i>
@@ -72,8 +72,8 @@ int f4(const int i) {
}
// CHECK: cir.func{{.*}} @_Z2f4i(%[[ARG:.*]]: !s32i {{.*}} loc({{.*}})) -> (!s32i {{.*}})
-// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init, const] {alignment = 4 : i64}
-// CHECK: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init const !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: cir.store{{.*}} %[[ARG]], %[[ARG_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[ARG_VAL:.*]] = cir.load{{.*}} %[[ARG_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CHECK: cir.store{{.*}} %[[ARG_VAL]], %[[RV]] : !s32i, !cir.ptr<!s32i>
@@ -92,12 +92,12 @@ int *f5() {
}
// CHECK: cir.func{{.*}} @_Z2f5v() -> (!cir.ptr<!s32i> {{.*}})
-// CHECK-NEXT: %[[RET_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["__retval"] {alignment = 8 : i64}
-// CHECK-NEXT: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p", init] {alignment = 8 : i64}
+// CHECK-NEXT: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: %[[NULLPTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store{{.*}} %[[NULLPTR]], %[[P_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+// CHECK-NEXT: %[[X_ADDR:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[X_ADDR]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store{{.*}} %[[X_ADDR]], %[[P_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -131,8 +131,8 @@ void ref_arg(int &x) {
}
// CHECK: cir.func{{.*}} @_Z7ref_argRi(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}})
-// CHECK: %[[X_REF_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["x", init, const] {alignment = 8 : i64}
-// CHECK: %[[Y_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
+// CHECK: %[[X_REF_ADDR:.*]] = cir.alloca "x" align(8) init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[Y_ADDR:.*]] = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK: cir.store{{.*}} %[[ARG]], %[[X_REF_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK: %[[X_REF:.*]] = cir.load{{.*}} %[[X_REF_ADDR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CHECK: %[[Y:.*]] = cir.load{{.*}} %[[X_REF]] : !cir.ptr<!s32i>, !s32i
@@ -148,7 +148,7 @@ short &return_ref() {
}
// CHECK: cir.func{{.*}} @_Z10return_refv() -> (!cir.ptr<!s16i> {{.*}})
-// CHECK: %[[RETVAL_ADDR:.*]] = cir.alloca !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
// CHECK: %[[GS_ADDR:.*]] = cir.get_global @gs : !cir.ptr<!s16i>
// CHECK: cir.store{{.*}} %[[GS_ADDR]], %[[RETVAL_ADDR]] : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
// CHECK: %[[RETVAL:.*]] = cir.load{{.*}} %[[RETVAL_ADDR]] : !cir.ptr<!cir.ptr<!s16i>>, !cir.ptr<!s16i>
@@ -159,7 +159,7 @@ void ref_local(short x) {
}
// CHECK: cir.func{{.*}} @_Z9ref_locals(%[[ARG:.*]]: !s16i {{.*}})
-// CHECK: %[[X_ADDR:.*]] = cir.alloca !s16i, !cir.ptr<!s16i>, ["x", init] {alignment = 2 : i64}
-// CHECK: %[[Y_REF_ADDR:.*]] = cir.alloca !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>, ["y", init, const] {alignment = 8 : i64}
+// CHECK: %[[X_ADDR:.*]] = cir.alloca "x" align(2) init !s16i -> !cir.ptr<!s16i>
+// CHECK: %[[Y_REF_ADDR:.*]] = cir.alloca "y" align(8) init const !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
// CHECK: cir.store{{.*}} %[[ARG]], %[[X_ADDR]] : !s16i, !cir.ptr<!s16i>
// CHECK: cir.store{{.*}} %[[X_ADDR]], %[[Y_REF_ADDR]] : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
diff --git a/clang/test/CIR/CodeGen/binassign.c b/clang/test/CIR/CodeGen/binassign.c
index dda52a8e4f319..8dd3985496b18 100644
--- a/clang/test/CIR/CodeGen/binassign.c
+++ b/clang/test/CIR/CodeGen/binassign.c
@@ -18,10 +18,10 @@ void binary_assign(void) {
}
// CIR-LABEL: cir.func{{.*}} @binary_assign()
-// CIR: %[[B:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b"]
-// CIR: %[[C:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, ["c"]
-// CIR: %[[F:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f"]
-// CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"]
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} !s8i -> !cir.ptr<!s8i>
+// CIR: %[[F:.*]] = cir.alloca "f" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store{{.*}} %[[TRUE]], %[[B]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
@@ -78,8 +78,8 @@ void binary_assign_struct() {
}
// CIR: cir.func{{.*}} @binary_assign_struct()
-// CIR: %[[LS:.*]] = cir.alloca ![[REC_S:.*]], !cir.ptr<![[REC_S]]>, ["ls"]
-// CIR: %[[LSV:.*]] = cir.alloca ![[REC_SV:.*]], !cir.ptr<![[REC_SV]]>, ["lsv"]
+// CIR: %[[LS:.*]] = cir.alloca "ls" {{.*}} ![[REC_S:.*]] -> !cir.ptr<![[REC_S]]>
+// CIR: %[[LSV:.*]] = cir.alloca "lsv" {{.*}} ![[REC_SV:.*]] -> !cir.ptr<![[REC_SV]]>
// CIR: %[[GS_PTR:.*]] = cir.get_global @gs : !cir.ptr<![[REC_S]]>
// CIR: cir.copy %[[GS_PTR]] to %[[LS]] : !cir.ptr<![[REC_S]]>
// CIR: %[[GSV_PTR:.*]] = cir.get_global @gsv : !cir.ptr<![[REC_SV]]>
@@ -112,12 +112,12 @@ int ignore_result_assign() {
}
// CIR-LABEL: cir.func{{.*}} @ignore_result_assign() -> !s32i
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["arr"]
-// CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"]
-// CIR: %[[J:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["j"]
-// CIR: %[[P:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p"]
-// CIR: %[[Q:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["q", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[J:.*]] = cir.alloca "j" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[Q:.*]] = cir.alloca "q" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[VAL_123:.*]] = cir.const #cir.int<123> : !s32i
// CIR: cir.store{{.*}} %[[VAL_123]], %[[I]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[VAL_123]], %[[J]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/binop.cpp b/clang/test/CIR/CodeGen/binop.cpp
index c4f116ae64345..b9bdc383b3360 100644
--- a/clang/test/CIR/CodeGen/binop.cpp
+++ b/clang/test/CIR/CodeGen/binop.cpp
@@ -206,9 +206,9 @@ void signed_shift(int a, int b) {
// CIR-LABEL: cir.func{{.*}} @_Z12signed_shiftii(
// CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !s32i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s32i, !cir.ptr<!s32i>
@@ -272,9 +272,9 @@ void unsigned_shift(unsigned a, unsigned b) {
// CIR-LABEL: cir.func{{.*}} @_Z14unsigned_shiftjj(
// CIR-SAME: %[[ARG0:.*]]: !u32i{{.*}}, %[[ARG1:.*]]: !u32i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !u32i, !cir.ptr<!u32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !u32i, !cir.ptr<!u32i>
@@ -338,9 +338,9 @@ void zext_shift_example(int a, unsigned char b) {
// CIR-LABEL: cir.func{{.*}} @_Z18zext_shift_exampleih(
// CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !u8i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !u8i -> !cir.ptr<!u8i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !u8i, !cir.ptr<!u8i>
@@ -410,9 +410,9 @@ void sext_shift_example(int a, signed char b) {
// CIR-LABEL: cir.func{{.*}} @_Z18sext_shift_exampleia(
// CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !s8i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s8i -> !cir.ptr<!s8i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s8i, !cir.ptr<!s8i>
@@ -482,9 +482,9 @@ void long_shift_example(long long a, short b) {
// CIR-LABEL: cir.func{{.*}} @_Z18long_shift_examplexs(
// CIR-SAME: %[[ARG0:.*]]: !s64i{{.*}}, %[[ARG1:.*]]: !s16i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s16i, !cir.ptr<!s16i>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s16i -> !cir.ptr<!s16i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s64i -> !cir.ptr<!s64i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s64i, !cir.ptr<!s64i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s16i, !cir.ptr<!s16i>
@@ -558,9 +558,9 @@ void b1(bool a, bool b) {
// CIR-LABEL: cir.func{{.*}} @_Z2b1bb(
// CIR-SAME: %[[ARG0:.*]]: !cir.bool {{.*}}, %[[ARG1:.*]]: !cir.bool {{.*}})
-// CIR: [[A:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init]
-// CIR: [[B:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
-// CIR: [[X:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init]
+// CIR: [[A:%[0-9]+]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: [[B:%[0-9]+]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: [[X:%[0-9]+]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG0]], [[A]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG1]], [[B]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: [[AVAL:%[0-9]+]] = cir.load align(1) [[A]] : !cir.ptr<!cir.bool>, !cir.bool
@@ -662,11 +662,11 @@ void b3(int a, int b, int c, int d) {
// CIR-LABEL: cir.func{{.*}} @_Z2b3iiii(
// CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}, %[[ARG1:.*]]: !s32i {{.*}}, %[[ARG2:.*]]: !s32i {{.*}}, %[[ARG3:.*]]: !s32i {{.*}})
-// CIR: [[A:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: [[B:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: [[C:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
-// CIR: [[D:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["d", init]
-// CIR: [[X:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init]
+// CIR: [[A:%[0-9]+]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[B:%[0-9]+]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[C:%[0-9]+]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[D:%[0-9]+]] = cir.alloca "d" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[X:%[0-9]+]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG0]], [[A]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %[[ARG1]], [[B]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %[[ARG2]], [[C]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/bitfield-union.c b/clang/test/CIR/CodeGen/bitfield-union.c
index d1d966e83f40a..d16afbb2acd21 100644
--- a/clang/test/CIR/CodeGen/bitfield-union.c
+++ b/clang/test/CIR/CodeGen/bitfield-union.c
@@ -40,7 +40,7 @@ void f() {
// CIR: #bfi_z = #cir.bitfield_info<name = "z", storage_type = !u8i, size = 8, offset = 0, is_signed = true>
// CIR: cir.func {{.*}} @f
-// CIR: [[ALLOC:%.*]] = cir.alloca !rec_demo, !cir.ptr<!rec_demo>, ["d"] {alignment = 4 : i64}
+// CIR: [[ALLOC:%.*]] = cir.alloca "d" align(4) !rec_demo -> !cir.ptr<!rec_demo>
// CIR: [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
// CIR: [[X:%.*]] = cir.get_member [[ALLOC]][0] {name = "x"} : !cir.ptr<!rec_demo> -> !cir.ptr<!s32i>
// CIR: cir.store align(4) [[ONE]], [[X]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c
index 801a0785b50dc..fef2c4d897fd0 100644
--- a/clang/test/CIR/CodeGen/bitfields.c
+++ b/clang/test/CIR/CodeGen/bitfields.c
@@ -95,7 +95,7 @@ int load_field(S* s) {
}
// CIR: cir.func {{.*@load_field}}
-// CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init]
+// CIR: [[TMP0:%.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
@@ -123,7 +123,7 @@ unsigned int load_field_unsigned(A* s) {
}
//CIR: cir.func {{.*}} @load_field_unsigned
-//CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["s", init] {alignment = 8 : i64}
+//CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
//CIR: [[TMP1:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
//CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][3] {name = "more_bits"} : !cir.ptr<!rec_A> -> !cir.ptr<!u16i>
//CIR: [[TMP3:%.*]] = cir.get_bitfield align(1) (#bfi_more_bits, [[TMP2]] : !cir.ptr<!u16i>) -> !u32i
@@ -151,7 +151,7 @@ void store_field() {
s.e = 3;
}
// CIR: cir.func {{.*@store_field}}
-// CIR: [[TMP0:%.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>
+// CIR: [[TMP0:%.*]] = cir.alloca {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP0]][1] {name = "e"} : !cir.ptr<!rec_S> -> !cir.ptr<!u16i>
// CIR: cir.set_bitfield align(4) (#bfi_e, [[TMP2]] : !cir.ptr<!u16i>, [[TMP1]] : !s32i)
@@ -178,7 +178,7 @@ void store_bitfield_to_bitfield() {
}
// CIR: cir.func {{.*@store_bitfield_to_bitfield}}
-// CIR: [[TMP0:%.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s"] {alignment = 4 : i64}
+// CIR: [[TMP0:%.*]] = cir.alloca "s" align(4) !rec_S -> !cir.ptr<!rec_S>
// CIR: [[TMP1:%.*]] = cir.get_member [[TMP0]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP2:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP1]] : !cir.ptr<!u64i>) -> !s32i
// CIR: [[TMP3:%.*]] = cir.get_member [[TMP0]][0] {name = "a"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
@@ -229,7 +229,7 @@ void get_volatile(V* v) {
}
// CIR: cir.func {{.*}} @get_volatile
-// CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_V>, !cir.ptr<!cir.ptr<!rec_V>>, ["v", init] {alignment = 8 : i64}
+// CIR: [[TMP0:%.*]] = cir.alloca "v" align(8) init !cir.ptr<!rec_V> -> !cir.ptr<!cir.ptr<!rec_V>>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_V>>, !cir.ptr<!rec_V>
// CIR: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "b"} : !cir.ptr<!rec_V> -> !cir.ptr<!u64i>
@@ -256,7 +256,7 @@ void set_volatile(V* v) {
v->b = 3;
}
//CIR: cir.func {{.*}} @set_volatile
-//CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_V>, !cir.ptr<!cir.ptr<!rec_V>>, ["v", init] {alignment = 8 : i64}
+//CIR: [[TMP0:%.*]] = cir.alloca "v" align(8) init !cir.ptr<!rec_V> -> !cir.ptr<!cir.ptr<!rec_V>>
//CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
//CIR: [[TMP2:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_V>>, !cir.ptr<!rec_V>
//CIR: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "b"} : !cir.ptr<!rec_V> -> !cir.ptr<!u64i>
@@ -284,7 +284,7 @@ void unOp(S* s) {
}
// CIR: cir.func {{.*@unOp}}
-// CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init] {alignment = 8 : i64}
+// CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "d"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_d, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
diff --git a/clang/test/CIR/CodeGen/bitfields.cpp b/clang/test/CIR/CodeGen/bitfields.cpp
index a3cbe02e35b6e..bd6c6b8169c16 100644
--- a/clang/test/CIR/CodeGen/bitfields.cpp
+++ b/clang/test/CIR/CodeGen/bitfields.cpp
@@ -36,7 +36,7 @@ int load_field(S* s) {
return s->c;
}
// CIR: cir.func {{.*}} @_Z10load_field
-// CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init]
+// CIR: [[TMP0:%.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
@@ -64,7 +64,7 @@ void store_field() {
s.a = 3;
}
// CIR: cir.func {{.*}} @_Z11store_field
-// CIR: [[TMP0:%.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>
+// CIR: [[TMP0:%.*]] = cir.alloca {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP0]][0] {name = "a"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: cir.set_bitfield align(4) (#bfi_a, [[TMP2]] : !cir.ptr<!u64i>, [[TMP1]] : !s32i)
@@ -89,7 +89,7 @@ void store_bitfield_to_bitfield(S* s) {
}
// CIR: cir.func {{.*}} @_Z26store_bitfield_to_bitfieldP1S
-// CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init] {alignment = 8 : i64}
+// CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "b"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/bitfields_be.c b/clang/test/CIR/CodeGen/bitfields_be.c
index 02ea231327f4e..c7da29717a3e7 100644
--- a/clang/test/CIR/CodeGen/bitfields_be.c
+++ b/clang/test/CIR/CodeGen/bitfields_be.c
@@ -22,7 +22,7 @@ int init(S* s) {
}
//CIR: cir.func {{.*}} @init
-//CIR: [[TMP0:%.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init] {alignment = 8 : i64}
+//CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
//CIR: [[TMP1:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
//CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u32i>
//CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u32i>) -> !s32i
@@ -52,7 +52,7 @@ void load(S* s) {
// field 'a'
// CIR: cir.func {{.*}} @load
-// CIR: %[[PTR0:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init]
+// CIR: %[[PTR0:.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[CONST1:.*]] = cir.const #cir.int<-4> : !s32i
// CIR: %[[VAL0:.*]] = cir.load align(8) %[[PTR0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: %[[GET0:.*]] = cir.get_member %[[VAL0]][0] {name = "a"} : !cir.ptr<!rec_S> -> !cir.ptr<!u32i>
diff --git a/clang/test/CIR/CodeGen/builtins-x86.c b/clang/test/CIR/CodeGen/builtins-x86.c
index 41a6808fce747..110b68d119fda 100644
--- a/clang/test/CIR/CodeGen/builtins-x86.c
+++ b/clang/test/CIR/CodeGen/builtins-x86.c
@@ -213,8 +213,8 @@ v4i test_convertvector(v4f a) {
void foo();
void test_conditional_bzero(void) {
// CIR-LABEL: test_conditional_bzero
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!s8i x 20>
-// CIR: %[[SIZE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
+// CIR: %[[ARR:.*]] = cir.alloca {{.*}} !cir.array<!s8i x 20>
+// CIR: %[[SIZE:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!s8i x 20>> -> !cir.ptr<!s8i>
// CIR: %[[ARR_TO_VOID_PTR:.*]] = cir.cast bitcast %[[ARR_DECAY]] : !cir.ptr<!s8i> -> !cir.ptr<!void>
// CIR: %[[SIZE_LOAD:.*]] = cir.load {{.*}}%[[SIZE]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
index de3369e169bb2..13df5e29a1749 100644
--- a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
+++ b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
@@ -50,8 +50,8 @@ class C {
void fn2() { C c1; c1.call_indirect(2); }
// CIR: cir.func {{.*}} @_ZN1C13call_indirectEi(%[[THIS_ARG:.*]]: !cir.ptr<!rec_C> {{.*}}, %[[V_ARG:.*]]: !s32i {{.*}}) -> (!s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init]
-// CIR: %[[V_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["v", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[V_ADDR:.*]] = cir.alloca "v" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store %[[V_ARG]], %[[V_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
diff --git a/clang/test/CIR/CodeGen/call.c b/clang/test/CIR/CodeGen/call.c
index 70839ff8efa52..2f837a9f66114 100644
--- a/clang/test/CIR/CodeGen/call.c
+++ b/clang/test/CIR/CodeGen/call.c
@@ -90,7 +90,7 @@ void f9(void) {
}
// CIR-LABEL: cir.func{{.*}} @f9(){{.*}} {
-// CIR: %[[SLOT:.+]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["agg.tmp0"] {alignment = 4 : i64}
+// CIR: %[[SLOT:.+]] = cir.alloca "agg.tmp0" align(4) !rec_S -> !cir.ptr<!rec_S>
// CIR-NEXT: %[[RET:.+]] = cir.call @f3() : () -> !rec_S
// CIR-NEXT: cir.store align(4) %[[RET]], %[[SLOT]] : !rec_S, !cir.ptr<!rec_S>
// CIR-NEXT: %[[ARG:.+]] = cir.load align(4) %[[SLOT]] : !cir.ptr<!rec_S>, !rec_S
diff --git a/clang/test/CIR/CodeGen/call.cpp b/clang/test/CIR/CodeGen/call.cpp
index 28b0479321131..3ec562bacd64e 100644
--- a/clang/test/CIR/CodeGen/call.cpp
+++ b/clang/test/CIR/CodeGen/call.cpp
@@ -35,7 +35,7 @@ int f6() {
}
// CIR-LABEL: cir.func{{.*}} @_Z2f6v() -> (!s32i{{.*}})
-// CIR: %[[#b:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[#b:]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[#a:]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[#c:]] = cir.const #false
// CIR-NEXT: %{{.+}} = cir.call @_Z2f5iPib(%[[#a]], %[[#b:]], %[[#c]]) : (!s32i {{.*}}, !cir.ptr<!s32i> {{.*}}, !cir.bool {{.*}}) -> (!s32i{{.*}})
@@ -94,7 +94,7 @@ void f12() {
}
// CIR-LABEL: cir.func{{.*}} @_Z3f12v()
-// CIR: %[[#slot:]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["agg.tmp0"]
+// CIR: %[[#slot:]] = cir.alloca "agg.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR-NEXT: %[[#ret:]] = cir.call @_Z3f10v() : () -> !rec_S
// CIR-NEXT: cir.store align(4) %[[#ret]], %[[#slot]] : !rec_S, !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/cast-cxx20.cpp b/clang/test/CIR/CodeGen/cast-cxx20.cpp
index 802bcecafcb70..87783f64822b1 100644
--- a/clang/test/CIR/CodeGen/cast-cxx20.cpp
+++ b/clang/test/CIR/CodeGen/cast-cxx20.cpp
@@ -14,8 +14,8 @@ void cast1() {
ArrNTy &toArr = arr;
// CIR-LABEL: cir.func {{.*}}@_Z5cast1v()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 4>, !cir.ptr<!cir.array<!s32i x 4>>, ["arr", init]
- // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>, ["toArr", init, const]
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
+ // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TO_INCOMPLETE:.*]] = cir.cast bitcast %[[ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 4>> -> !cir.ptr<!cir.array<!s32i x 0>>
// CIR: cir.store {{.*}}%[[TO_INCOMPLETE]], %[[TO_ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
@@ -29,8 +29,8 @@ void cast2() {
Arr4Ty arr = {};
CArrNTy &toArr = arr;
// CIR-LABEL: cir.func {{.*}}@_Z5cast2v()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 4>, !cir.ptr<!cir.array<!s32i x 4>>, ["arr", init]
- // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>, ["toArr", init, const]
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
+ // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TO_INCOMPLETE:.*]] = cir.cast bitcast %[[ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 4>> -> !cir.ptr<!cir.array<!s32i x 0>>
// CIR: cir.store {{.*}}%[[TO_INCOMPLETE]], %[[TO_ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
//
@@ -43,8 +43,8 @@ void cast2() {
void cast3() {
int (&&toArr)[] = static_cast<int[]>(3);
// CIR-LABEL: cir.func {{.*}}@_Z5cast3v()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 1>, !cir.ptr<!cir.array<!s32i x 1>>, ["ref.tmp0"]
- // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>, ["toArr", init, const]
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.array<!s32i x 1> -> !cir.ptr<!cir.array<!s32i x 1>>
+ // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TO_INCOMPLETE:.*]] = cir.cast bitcast %[[TMP_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!cir.array<!s32i x 0>>
// CIR: cir.store {{.*}}%[[TO_INCOMPLETE]], %[[TO_ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
//
@@ -59,8 +59,8 @@ void cast4() {
CArrNTy* const volatile *const constArrPP = arrPP;
// CIR-LABEL: cir.func {{.*}}@_Z5cast4v()
- // CIR: %[[ARR_PP_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>, ["arrPP"]
- // CIR: %[[CONST_ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>>, ["constArrPP", init, const]
+ // CIR: %[[ARR_PP_ALLOCA:.*]] = cir.alloca "arrPP" {{.*}} !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
+ // CIR: %[[CONST_ARR_ALLOCA:.*]] = cir.alloca "constArrPP" {{.*}} init const !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>>
// CIR: %[[LOAD_ARR_PP:.*]] = cir.load align(8) %[[ARR_PP_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>
// CIR: %[[CONST_ARR_CAST:.*]] = cir.cast bitcast %[[CONST_ARR_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
// CIR: cir.store{{.*}} %[[LOAD_ARR_PP]], %[[CONST_ARR_CAST]] : !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
diff --git a/clang/test/CIR/CodeGen/cast.c b/clang/test/CIR/CodeGen/cast.c
index cce29c49d2039..35c3071c41c7c 100644
--- a/clang/test/CIR/CodeGen/cast.c
+++ b/clang/test/CIR/CodeGen/cast.c
@@ -28,7 +28,7 @@ union Union toUnionAssign() {
// CIR-LABEL: toUnionAssign()
// LLVM-LABEL: toUnionAssign()
//
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !rec_Union, !cir.ptr<!rec_Union>, ["__retval"]
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_Union -> !cir.ptr<!rec_Union>
// LLVM: %[[RET_ALLOCA:.*]] = alloca %union.Union
union Union u;
u = (union Union)42;
diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp
index aef565ee332af..a81a90ffa89be 100644
--- a/clang/test/CIR/CodeGen/cast.cpp
+++ b/clang/test/CIR/CodeGen/cast.cpp
@@ -8,8 +8,8 @@ unsigned char cxxstaticcast_0(unsigned int x) {
}
// CIR: cir.func{{.*}} @_Z15cxxstaticcast_0j
-// CIR: %[[XPTR:[0-9]+]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] {alignment = 4 : i64}
-// CIR: %[[RV:[0-9]+]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["__retval"] {alignment = 1 : i64}
+// CIR: %[[XPTR:[0-9]+]] = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[RV:[0-9]+]] = cir.alloca "__retval" align(1) !u8i -> !cir.ptr<!u8i>
// CIR: cir.store %arg0, %[[XPTR]] : !u32i, !cir.ptr<!u32i>
// CIR: %[[XVAL:[0-9]+]] = cir.load{{.*}} %[[XPTR]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[CASTED:[0-9]+]] = cir.cast integral %[[XVAL]] : !u32i -> !u8i
@@ -90,7 +90,7 @@ bool cptr(void *d) {
}
// CIR: cir.func{{.*}} @_Z4cptrPv(%arg0: !cir.ptr<!void>
-// CIR: %[[DPTR:[0-9]+]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["d", init] {alignment = 8 : i64}
+// CIR: %[[DPTR:[0-9]+]] = cir.alloca "d" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[DVAL:[0-9]+]] = cir.load{{.*}} %[[DPTR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %{{[0-9]+}} = cir.cast ptr_to_bool %[[DVAL]] : !cir.ptr<!void> -> !cir.bool
diff --git a/clang/test/CIR/CodeGen/choose-expr.cpp b/clang/test/CIR/CodeGen/choose-expr.cpp
index 7a980e2ea8b9b..66d8597de3c6e 100644
--- a/clang/test/CIR/CodeGen/choose-expr.cpp
+++ b/clang/test/CIR/CodeGen/choose-expr.cpp
@@ -9,7 +9,7 @@ void choose_expr() {
int a = __builtin_choose_expr(1, 2, 3);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i
// CIR: cir.store {{.*}} %[[CONST_2]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
@@ -25,9 +25,9 @@ void choose_expr_non_constant() {
int c = __builtin_choose_expr(1, a, b);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store {{.*}} %[[TMP_A]], %[[C_ADDR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/class.cpp b/clang/test/CIR/CodeGen/class.cpp
index 8481d65616a43..1d63accdfe489 100644
--- a/clang/test/CIR/CodeGen/class.cpp
+++ b/clang/test/CIR/CodeGen/class.cpp
@@ -52,7 +52,7 @@ class Derived : public Base {
int use(Derived *d) { return d->b; }
// CIR: cir.func{{.*}} @_Z3useP7Derived(%[[ARG0:.*]]: !cir.ptr<!rec_Derived>
-// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["d", init]
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[ARG0]], %[[D_ADDR]]
// CIR: %[[D_PTR:.*]] = cir.load align(8) %0
// CIR: %[[D_B_ADDR:.*]] = cir.get_member %[[D_PTR]][1] {name = "b"}
@@ -70,7 +70,7 @@ int use_base() {
}
// CIR: cir.func{{.*}} @_Z8use_basev
-// CIR: %[[D_ADDR:.*]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["d"]
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} !rec_Derived -> !cir.ptr<!rec_Derived>
// CIR: %[[BASE_ADDR:.*]] cir.base_class_addr %[[D_ADDR]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[D_A_ADDR:.*]] = cir.get_member %2[0] {name = "a"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: %[[D_A:.*]] = cir.load align(4) %3 : !cir.ptr<!s32i>, !s32i
@@ -88,7 +88,7 @@ int use_base_via_pointer(Derived *d) {
}
// CIR: cir.func{{.*}} @_Z20use_base_via_pointerP7Derived(%[[ARG0:.*]]: !cir.ptr<!rec_Derived>
-// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["d", init]
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[ARG0]], %[[D_ADDR]]
// CIR: %[[D:.*]] = cir.load align(8) %[[D_ADDR]]
// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[D]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
@@ -109,7 +109,7 @@ void use_empty_derived2() {
}
// CIR: cir.func{{.*}} @_Z18use_empty_derived2v()
-// CIR: %0 = cir.alloca !rec_EmptyDerived2, !cir.ptr<!rec_EmptyDerived2>, ["d2"]
+// CIR: %0 = cir.alloca "d2" {{.*}} !rec_EmptyDerived2 -> !cir.ptr<!rec_EmptyDerived2>
// CIR: cir.return
// LLVM: define{{.*}} void @_Z18use_empty_derived2v
diff --git a/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp b/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp
index c6bd774971ef7..f772ea8362ba1 100644
--- a/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp
@@ -18,8 +18,8 @@ void test_cleanup_with_automatic_storage_duration() {
}
// CIR: cir.func{{.*}} @_Z44test_cleanup_with_automatic_storage_durationv()
-// CIR: %[[REF_TMP:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["ref.tmp0"]
-// CIR: %[[REF:.*]] = cir.alloca !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>, ["ref", init, const]
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CIR: %[[REF:.*]] = cir.alloca "ref" {{.*}} init const !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
// CIR: cir.call @_ZN5StrukC1Ev(%[[REF_TMP]])
// CIR: cir.cleanup.scope {
// CIR: cir.store{{.*}} %[[REF_TMP]], %[[REF]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
index 4e37c234f62b6..a870ea8481965 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
@@ -32,8 +32,8 @@ void test_ternary_temporary(bool c, int x) {
int result = c ? S().get() : x;
}
// CIR-LABEL: @_Z22test_ternary_temporarybi
-// CIR: %[[TMP:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["ref.tmp0"]
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE:.*]] = cir.const #false
@@ -135,10 +135,10 @@ void test_ternary_both_branches(bool c) {
int result = c ? A().get() : B().get();
}
// CIR-LABEL: @_Z26test_ternary_both_branchesb
-// CIR: %[[TMPA:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["ref.tmp0"]
-// CIR: %[[ACTA:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[TMPB:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp1"]
-// CIR: %[[ACTB:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE_A:.*]] = cir.const #false
@@ -277,10 +277,10 @@ int test_return_ternary(bool c) {
return c ? A().get() : B().get();
}
// CIR-LABEL: @_Z19test_return_ternaryb
-// CIR: %[[TMPA:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["ref.tmp0"]
-// CIR: %[[ACTA:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[TMPB:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp1"]
-// CIR: %[[ACTB:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE_A:.*]] = cir.const #false
@@ -429,8 +429,8 @@ int test_false_positive_conditional(bool c) {
return S().get() ? 1 : 2;
}
// CIR-LABEL: @_Z31test_false_positive_conditionalb
-// CIR-NOT: cir.alloca {{.*}} ["cleanup.cond"]
-// CIR: %[[TMP:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["ref.tmp0"]
+// CIR-NOT: cir.alloca "cleanup.cond" {{.*}}
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev(%[[TMP]])
// CIR: cir.cleanup.scope {
// CIR: %[[VAL:.*]] = cir.call @_ZN1S3getEv(%[[TMP]])
@@ -514,11 +514,11 @@ void test_nested_ewc(bool c1, bool c2) {
}
// CIR-LABEL: @_Z15test_nested_ewcbb
-// CIR: %[[RESULT:.*]] = cir.alloca !rec_T, !cir.ptr<!rec_T>, ["result", init]
-// CIR: %[[REF_TMP:.*]] = cir.alloca !rec_T, !cir.ptr<!rec_T>, ["ref.tmp0"]
+// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_T -> !cir.ptr<!rec_T>
// Inner cir.scope for the statement expression.
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca !rec_T, !cir.ptr<!rec_T>, ["s", init]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
// Inner ternary: c1 ? T(1) : T(2) — no cleanup scope needed.
// CIR: %[[C1:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: cir.if %[[C1]] {
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional.cpp b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
index 2bb1e1313e43a..15b0170aa63c2 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
@@ -15,8 +15,8 @@ void test_ternary_temporary(bool c, int x) {
int result = c ? S().get() : x;
}
// CIR-LABEL: @_Z22test_ternary_temporarybi
-// CIR: %[[TMP:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["ref.tmp0"]
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// The cleanup scope wraps the full expression so cleanups run on all exits.
// CIR: cir.cleanup.scope {
// Load condition, then active flag false before the ternary (destructor guard).
@@ -117,10 +117,10 @@ void test_ternary_both_branches(bool c) {
int result = c ? A().get() : B().get();
}
// CIR-LABEL: @_Z26test_ternary_both_branchesb
-// CIR: %[[TMPA:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["ref.tmp0"]
-// CIR: %[[ACTA:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[TMPB:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp1"]
-// CIR: %[[ACTB:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// Both active flags start false; each branch sets its own to true when it runs.
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
@@ -234,10 +234,10 @@ int test_return_ternary(bool c) {
return c ? A().get() : B().get();
}
// CIR-LABEL: @_Z19test_return_ternaryb
-// CIR: %[[TMPA:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["ref.tmp0"]
-// CIR: %[[ACTA:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[TMPB:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp1"]
-// CIR: %[[ACTB:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE_A:.*]] = cir.const #false
@@ -365,8 +365,8 @@ int test_false_positive_conditional(bool c) {
return S().get() ? 1 : 2;
}
// No cleanup.cond alloca — the destructor is unconditional.
-// CIR-NOT: cir.alloca {{.*}} ["cleanup.cond"]
-// CIR: %[[TMP:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["ref.tmp0"]
+// CIR-NOT: cir.alloca "cleanup.cond" {{.*}}
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev(%[[TMP]])
// The cleanup scope wraps the get() + select + store.
// CIR: cir.cleanup.scope {
@@ -435,11 +435,11 @@ void test_nested_ewc(bool c1, bool c2) {
}
// CIR-LABEL: @_Z15test_nested_ewcbb
-// CIR: %[[RESULT:.*]] = cir.alloca !rec_T, !cir.ptr<!rec_T>, ["result", init]
-// CIR: %[[REF_TMP:.*]] = cir.alloca !rec_T, !cir.ptr<!rec_T>, ["ref.tmp0"]
+// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_T -> !cir.ptr<!rec_T>
// cir.scope for the statement expression.
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca !rec_T, !cir.ptr<!rec_T>, ["s", init]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
// Inner ternary: c1 ? T(1) : T(2) — no cleanup scope needed (no deferred dtors).
// CIR: %[[C1:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: cir.if %[[C1]] {
@@ -576,11 +576,11 @@ void test_lvalue_ternary_cleanup(bool c, V &y) {
y = c ? V(1) : V(2);
}
// CIR-LABEL: @_Z27test_lvalue_ternary_cleanupbR1V
-// CIR: %[[REFTMP:.*]] = cir.alloca !rec_V, !cir.ptr<!rec_V>, ["ref.tmp0"]
-// CIR: %[[UTRUE:.*]] = cir.alloca !rec_U, !cir.ptr<!rec_U>, ["ref.tmp1"]
-// CIR: %[[ACTTRUE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[UFALSE:.*]] = cir.alloca !rec_U, !cir.ptr<!rec_U>, ["ref.tmp2"]
-// CIR: %[[ACTFALSE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[REFTMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_V -> !cir.ptr<!rec_V>
+// CIR: %[[UTRUE:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_U -> !cir.ptr<!rec_U>
+// CIR: %[[ACTTRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[UFALSE:.*]] = cir.alloca "ref.tmp2" {{.*}} !rec_U -> !cir.ptr<!rec_U>
+// CIR: %[[ACTFALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// The outer cleanup scope wraps the full expression containing the ternary
// and the operator= call.
// CIR: cir.cleanup.scope {
@@ -702,13 +702,13 @@ void test_lvalue_reload(bool c) {
sink = &r;
}
// CIR-LABEL: @_Z18test_lvalue_reloadb
-// CIR: %[[R_REF:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["r", init, const]
-// CIR: %[[TMP0:.*]] = cir.alloca !rec_R, !cir.ptr<!rec_R>, ["ref.tmp0"]
-// CIR: %[[ACT0:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[TMP1:.*]] = cir.alloca !rec_R, !cir.ptr<!rec_R>, ["ref.tmp1"]
-// CIR: %[[ACT1:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[R_REF:.*]] = cir.alloca "r" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_R -> !cir.ptr<!rec_R>
+// CIR: %[[ACT0:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_R -> !cir.ptr<!rec_R>
+// CIR: %[[ACT1:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// The spill slot for the lvalue's base pointer.
-// CIR: %[[SPILL:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["tmp.exprcleanup"]
+// CIR: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.cleanup.scope {
// CIR: cir.store {{.*}}, %[[ACT0]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: cir.store {{.*}}, %[[ACT1]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -807,8 +807,8 @@ _Complex float test_complex_cond_cleanup(bool b, _Complex float x) {
return b ? CplxD().get() : x;
}
// CIR-LABEL: @_Z25test_complex_cond_cleanupbCf
-// CIR: %[[TMP:.*]] = cir.alloca !rec_CplxD, !cir.ptr<!rec_CplxD>, ["ref.tmp0"]
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_CplxD -> !cir.ptr<!rec_CplxD>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// The full expression is wrapped in a single cleanup scope.
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp b/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp
index 2d2925605a137..3812ffa6c9e9b 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp
@@ -23,7 +23,7 @@ end:;
// CIR-LABEL: cir.func {{.*}} @_Z19test_goto_only_exitb
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_Z3useR20StructWithDestructor(%[[A_ADDR]])
// CIR: cir.goto "end"
@@ -82,7 +82,7 @@ end:;
// CIR-LABEL: cir.func {{.*}} @_Z27test_goto_among_other_exitsb
// CIR: cir.scope {
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
@@ -158,10 +158,10 @@ void test_goto_inner_to_outer(bool cond) {
}
// CIR-LABEL: cir.func {{.*}} @_Z24test_goto_inner_to_outerb
-// CIR: %[[OUTER_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["outer"]
+// CIR: %[[OUTER_ADDR:.*]] = cir.alloca "outer" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
-// CIR: %[[INNER_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["inner"]
+// CIR: %[[INNER_ADDR:.*]] = cir.alloca "inner" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
@@ -256,10 +256,10 @@ end:;
// CIR-LABEL: cir.func {{.*}} @_Z27test_goto_out_of_two_nestedb
// CIR: cir.scope {
-// CIR: %[[OUTER_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["outer"]
+// CIR: %[[OUTER_ADDR:.*]] = cir.alloca "outer" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
-// CIR: %[[INNER_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["inner"]
+// CIR: %[[INNER_ADDR:.*]] = cir.alloca "inner" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp b/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp
index eea94c20c00ca..e06b1a2396591 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp
@@ -21,7 +21,7 @@ void test_goto_within_cleanup(bool cond) {
}
// CIR-LABEL: cir.func {{.*}} @_Z24test_goto_within_cleanupb
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
@@ -87,7 +87,7 @@ void test_goto_jump_into_nested_op(bool cond1, bool cond2) {
}
// CIR-LABEL: cir.func {{.*}} @_Z29test_goto_jump_into_nested_opbb
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp b/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp
index d6ec4340bcba1..44486f1cee871 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp
@@ -8,7 +8,7 @@ struct StructWithDestructor {
void cleanup_scope_with_without_body() { StructWithDestructor a; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.yield
// CIR: } cleanup all {
@@ -21,7 +21,7 @@ void cleanup_scope_with_body_and_cleanup() {
a.procedure();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN20StructWithDestructor9procedureEv(%[[A_ADDR]]) : (!cir.ptr<!rec_StructWithDestructor> {{.*}}) -> ()
// CIR: cir.yield
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp b/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp
index b67211a46bcb6..580e5e35929bd 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp
@@ -8,7 +8,7 @@ struct StructWithDestructor {
void cleanup_scope_with_without_body() { StructWithDestructor a; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.yield
// CIR: } cleanup normal {
@@ -21,7 +21,7 @@ void cleanup_scope_with_body_and_cleanup() {
a.procedure();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithDestructor, !cir.ptr<!rec_StructWithDestructor>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN20StructWithDestructor9procedureEv(%[[A_ADDR]]) : (!cir.ptr<!rec_StructWithDestructor> {{.*}}) -> ()
// CIR: cir.yield
diff --git a/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp b/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp
index 0bcd211c1cd63..dd97db4273c4c 100644
--- a/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp
@@ -25,7 +25,7 @@ void test_throwing_dtor_cleanup() {
// High-level: the cleanup region's dtor call does NOT have nothrow.
//
// CIR: cir.func{{.*}} @_Z26test_throwing_dtor_cleanupv()
-// CIR: %[[C:.*]] = cir.alloca !rec_ThrowingDtor, !cir.ptr<!rec_ThrowingDtor>, ["c"]
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} !rec_ThrowingDtor -> !cir.ptr<!rec_ThrowingDtor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN12ThrowingDtor11doSomethingEv(%[[C]])
// CIR: cir.yield
@@ -38,7 +38,7 @@ void test_throwing_dtor_cleanup() {
// becomes a try_call that unwinds to a terminate block.
//
// CIR-FLAT: cir.func{{.*}} @_Z26test_throwing_dtor_cleanupv()
-// CIR-FLAT: %[[C:.*]] = cir.alloca !rec_ThrowingDtor, !cir.ptr<!rec_ThrowingDtor>, ["c"]
+// CIR-FLAT: %[[C:.*]] = cir.alloca "c" {{.*}} !rec_ThrowingDtor -> !cir.ptr<!rec_ThrowingDtor>
// CIR-FLAT: cir.br ^[[BODY:bb[0-9]+]]
//
// Body: doSomething becomes a try_call.
diff --git a/clang/test/CIR/CodeGen/cleanup.cpp b/clang/test/CIR/CodeGen/cleanup.cpp
index 5a2ff8cacfaf5..f043b875abe2c 100644
--- a/clang/test/CIR/CodeGen/cleanup.cpp
+++ b/clang/test/CIR/CodeGen/cleanup.cpp
@@ -14,7 +14,7 @@ void test_cleanup() {
}
// CHECK: cir.func{{.*}} @_Z12test_cleanupv()
-// CHECK: %[[S_ADDR:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s"]
+// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S_ADDR]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: cir.return
@@ -30,10 +30,10 @@ void test_cleanup_ifelse(bool b) {
// CHECK: cir.scope {
// CHECK: %[[B:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.bool>
// CHECK: cir.if %[[B]] {
-// CHECK: %[[S:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s"]
+// CHECK: %[[S:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: } else {
-// CHECK: %[[S_TOO:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s"]
+// CHECK: %[[S_TOO:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S_TOO]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: }
// CHECK: }
@@ -50,7 +50,7 @@ void test_cleanup_for() {
// CHECK: cir.for : cond {
// CHECK: } body {
// CHECK: cir.scope {
-// CHECK: %[[S:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s"]
+// CHECK: %[[S:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: }
// CHECK: cir.yield
@@ -70,11 +70,11 @@ void test_cleanup_nested() {
}
// CHECK: cir.func{{.*}} @_Z19test_cleanup_nestedv()
-// CHECK: %[[OUTER:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["outer"]
+// CHECK: %[[OUTER:.*]] = cir.alloca "outer" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.scope {
-// CHECK: %[[MIDDLE:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["middle"]
+// CHECK: %[[MIDDLE:.*]] = cir.alloca "middle" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.scope {
-// CHECK: %[[INNER:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["inner"]
+// CHECK: %[[INNER:.*]] = cir.alloca "inner" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[INNER]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: }
// CHECK: cir.call @_ZN5StrukD1Ev(%[[MIDDLE]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
@@ -89,7 +89,7 @@ void test_expr_with_cleanup() {
}
// CHECK: cir.func{{.*}} @_Z22test_expr_with_cleanupv()
-// CHECK: %[[S:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>
+// CHECK: %[[S:.*]] = cir.alloca {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_Z7use_refRK5Struk(%[[S]])
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: cir.return
@@ -104,9 +104,9 @@ void complex_expr_with_cleanup() {
}
// CHECK: cir.func{{.*}} @_Z25complex_expr_with_cleanupv()
-// CHECK: %[[RESULT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["result", init]
-// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca !rec_ComplexContainer, !cir.ptr<!rec_ComplexContainer>, ["ref.tmp0"]
-// CHECK: %[[ARG_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["coerce"]
+// CHECK: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_ComplexContainer -> !cir.ptr<!rec_ComplexContainer>
+// CHECK: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[CONST_10:.*]] = cir.const #cir.int<10> : !s32i
// CHECK: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CHECK: %[[ARG_COMPLEX:.*]] = cir.complex.create %[[CONST_10]], %[[CONST_0]] : !s32i -> !cir.complex<!s32i>
@@ -128,10 +128,10 @@ void complex_expr_with_cleanup_inside_cleanupscope() {
}
// CHECK: cir.func{{.*}} @_Z45complex_expr_with_cleanup_inside_cleanupscopev()
-// CHECK: %[[RESULT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["result", init]
-// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca !rec_ComplexContainerWithDtor, !cir.ptr<!rec_ComplexContainerWithDtor>, ["ref.tmp0"]
-// CHECK: %[[ARG_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["coerce"]
-// CHECK: %[[TEMP_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["tmp.exprcleanup"]
+// CHECK: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_ComplexContainerWithDtor -> !cir.ptr<!rec_ComplexContainerWithDtor>
+// CHECK: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[TEMP_ADDR:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[CONST_10:.*]] = cir.const #cir.int<10> : !s32i
// CHECK: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CHECK: %[[ARG_COMPLEX:.*]] = cir.complex.create %[[CONST_10]], %[[CONST_0]] : !s32i -> !cir.complex<!s32i>
@@ -155,8 +155,8 @@ void test_cleanup_with_automatic_storage_duration() {
}
// CHECK: cir.func{{.*}} @_Z44test_cleanup_with_automatic_storage_durationv()
-// CHECK: %[[REF_TMP:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["ref.tmp0"]
-// CHECK: %[[REF:.*]] = cir.alloca !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>, ["ref", init, const]
+// CHECK: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[REF:.*]] = cir.alloca "ref" {{.*}} init const !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: cir.cleanup.scope {
// CHECK: cir.store{{.*}} %[[REF_TMP]], %[[REF]]
// CHECK: cir.yield
diff --git a/clang/test/CIR/CodeGen/cmp.cpp b/clang/test/CIR/CodeGen/cmp.cpp
index 1e8569bf576e5..28c0e78974c9f 100644
--- a/clang/test/CIR/CodeGen/cmp.cpp
+++ b/clang/test/CIR/CodeGen/cmp.cpp
@@ -16,9 +16,9 @@ void c0(int a, int b) {
// CIR-LABEL: cir.func{{.*}} @_Z2c0ii(
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]]
// CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]]
@@ -142,9 +142,9 @@ void c0_unsigned(unsigned int a, unsigned int b) {
// CIR-LABEL: cir.func{{.*}} @_Z11c0_unsignedjj(
-// CIR: %[[U_A_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CIR: %[[U_B_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init]
-// CIR: %[[U_X_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init]
+// CIR: %[[U_A_PTR:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[U_B_PTR:.*]] = cir.alloca "b" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[U_X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[UA1:.*]] = cir.load{{.*}} %[[U_A_PTR]]
// CIR: %[[UB1:.*]] = cir.load{{.*}} %[[U_B_PTR]]
@@ -266,9 +266,9 @@ void c0_float(float a, float b) {
}
// CIR-LABEL: cir.func{{.*}} @_Z8c0_floatff(%arg0: !cir.float{{.*}}, %arg1: !cir.float{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store{{.*}} %arg0, %[[A_PTR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: cir.store{{.*}} %arg1, %[[B_PTR]] : !cir.float, !cir.ptr<!cir.float>
@@ -347,8 +347,8 @@ void pointer_cmp(int *a, int *b) {
}
// CIR-LABEL: cir.func{{.*}} @_Z11pointer_cmpPiS_(%arg0: !cir.ptr<!s32i>{{.*}}, %arg1: !cir.ptr<!s32i>{{.*}}){{.*}} {
-// CIR: %[[A_PTR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["b", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -402,9 +402,9 @@ void bool_cmp(bool a, bool b) {
}
// CIR-LABEL: cir.func{{.*}} @_Z8bool_cmpbb(%arg0: !cir.bool{{.*}}, %arg1: !cir.bool{{.*}}){{.*}} {
-// CIR: %[[A_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
-// CIR: %[[X_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[A1_INT:.*]] = cir.cast bool_to_int %[[A1]] : !cir.bool -> !s32i
diff --git a/clang/test/CIR/CodeGen/comma.c b/clang/test/CIR/CodeGen/comma.c
index b09a479076a54..ea513a241543f 100644
--- a/clang/test/CIR/CodeGen/comma.c
+++ b/clang/test/CIR/CodeGen/comma.c
@@ -17,10 +17,10 @@ void comma(void) {
}
// CIR-LABEL: cir.func{{.*}} @comma()
-// CIR: %[[B:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b"]
-// CIR: %[[C:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, ["c"]
-// CIR: %[[F:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f"]
-// CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"]
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} !s8i -> !cir.ptr<!s8i>
+// CIR: %[[F:.*]] = cir.alloca "f" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store{{.*}} %[[TRUE]], %[[B]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
diff --git a/clang/test/CIR/CodeGen/complex-atomic-cast.c b/clang/test/CIR/CodeGen/complex-atomic-cast.c
index a15858fcf9711..5a1f71f8ab8d8 100644
--- a/clang/test/CIR/CodeGen/complex-atomic-cast.c
+++ b/clang/test/CIR/CodeGen/complex-atomic-cast.c
@@ -10,8 +10,8 @@ void complex_to_atomic_complex() {
_Atomic _Complex int b = a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store {{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
diff --git a/clang/test/CIR/CodeGen/complex-builtins.cpp b/clang/test/CIR/CodeGen/complex-builtins.cpp
index 9a6ca7562ecf7..0627597223069 100644
--- a/clang/test/CIR/CodeGen/complex-builtins.cpp
+++ b/clang/test/CIR/CodeGen/complex-builtins.cpp
@@ -11,8 +11,8 @@ void foo() {
int _Complex r = __builtin_choose_expr(true, a, b);
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[COMPLEX_R:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["r", init]
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_R:.*]] = cir.alloca "r" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[COMPLEX_R]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -39,8 +39,8 @@ void foo2() {
double real = __builtin_creal(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["a"]
-// CIR: %[[INIT:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["real", init]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "real" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[REAL]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -64,8 +64,8 @@ void foo3() {
double imag = __builtin_cimag(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["a"]
-// CIR: %[[INIT:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["imag", init]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "imag" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[IMAG]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -89,8 +89,8 @@ void foo4() {
float _Complex b = __builtin_conjf(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex-cast.cpp b/clang/test/CIR/CodeGen/complex-cast.cpp
index bcc057252e55e..ea35111c860ef 100644
--- a/clang/test/CIR/CodeGen/complex-cast.cpp
+++ b/clang/test/CIR/CodeGen/complex-cast.cpp
@@ -385,8 +385,8 @@ void complex_user_defined_cast() {
int _Complex c = p;
}
-// CIR: %[[P_ADDR:.*]] = cir.alloca !rec_Point, !cir.ptr<!rec_Point>, ["p", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[P_VALUE:.*]] = cir.get_global @__const._Z25complex_user_defined_castv.p : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[P_VALUE]] to %[[P_ADDR]] : !cir.ptr<!rec_Point>
// CIR: %[[POINT_TO_COMPLEX:.*]] = cir.call @_ZZ25complex_user_defined_castvENK5PointcvCiEv(%[[P_ADDR]]) : (!cir.ptr<!rec_Point> {llvm.align = 4 : i64, llvm.dereferenceable = 8 : i64, llvm.nonnull, llvm.noundef}) -> (!cir.complex<!s32i> {llvm.noundef})
diff --git a/clang/test/CIR/CodeGen/complex-compound-assignment.cpp b/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
index ffb16c1ffb46f..adb34fff72fb6 100644
--- a/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
+++ b/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
@@ -17,8 +17,8 @@ void foo() {
b += a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT:.*]] = cir.complex.add %[[TMP_B]], %[[TMP_A]] : !cir.complex<!cir.float>
@@ -61,8 +61,8 @@ void foo1() {
b -= a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT:.*]] = cir.complex.sub %[[TMP_B]], %[[TMP_A]] : !cir.complex<!cir.float>
@@ -105,8 +105,8 @@ void foo2() {
b += a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[RESULT:.*]] = cir.complex.add %[[TMP_B]], %[[TMP_A]] : !cir.complex<!s32i>
@@ -149,8 +149,8 @@ void foo3() {
b += a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
// 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
@@ -234,9 +234,9 @@ void foo4() {
}
#endif
-// CXX_CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CXX_CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
-// CXX_CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CXX_CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CXX_CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CXX_CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CXX_CIR: %[[TMP_A:.*]] = cir.load volatile {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CXX_CIR: %[[TMP_B:.*]] = cir.load volatile {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CXX_CIR: %[[RESULT:.*]] = cir.complex.add %[[TMP_B]], %[[TMP_A]] : !cir.complex<!s32i>
@@ -293,8 +293,8 @@ void foo5() {
a += b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// 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
@@ -333,8 +333,8 @@ void foo6() {
b *= a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!s32i> -> !s32i
@@ -395,8 +395,8 @@ void foo7() {
b *= a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!cir.float> -> !cir.float
@@ -497,8 +497,8 @@ void foo8() {
a *= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// 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
@@ -540,8 +540,8 @@ void foo10() {
a /= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// 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
@@ -590,8 +590,8 @@ void foo11() {
a /= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// 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
@@ -633,8 +633,8 @@ void foo12() {
a /= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[B_COMPLEX:.*]] = cir.complex.create %[[TMP_B]], %[[CONST_0]] : !s32i -> !cir.complex<!s32i>
@@ -707,8 +707,8 @@ void foo13() {
b /= (a / b);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
// 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
@@ -828,8 +828,8 @@ void foo9() {
}
#endif
-// C_CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// C_CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b"]
+// C_CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// C_CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// C_CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// C_CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// C_CIR: %[[A_REAL:.*]] = cir.complex.real %[[A_ADDR]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex-mul-div.cpp b/clang/test/CIR/CodeGen/complex-mul-div.cpp
index 3ae1544309382..a8125e2c48621 100644
--- a/clang/test/CIR/CodeGen/complex-mul-div.cpp
+++ b/clang/test/CIR/CodeGen/complex-mul-div.cpp
@@ -46,9 +46,9 @@ void foo() {
// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(promoted) : !cir.complex<!cir.float>
-// CIR-AFTER-MUL-COMBINED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-MUL-COMBINED: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-MUL-COMBINED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-MUL-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-MUL-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-MUL-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-MUL-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-MUL-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-MUL-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -107,9 +107,9 @@ void foo() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -220,9 +220,9 @@ void foo1() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) : !cir.complex<!s32i>
-// CIR-AFTER-INT: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-AFTER-INT: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
-// CIR-AFTER-INT: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR-AFTER-INT: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER-INT: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER-INT: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR-AFTER-INT: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-AFTER-INT: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-AFTER-INT: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!s32i> -> !s32i
@@ -285,9 +285,9 @@ void foo2() {
float _Complex c = a * b;
}
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b"]
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %1 : !cir.ptr<!cir.float>, !cir.float
// CIR-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -333,9 +333,9 @@ void foo3() {
// CIR-BEFORE-BASIC: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(basic) : !cir.complex<!cir.float>
-// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-BASIC: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-BASIC: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-BASIC: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -409,9 +409,9 @@ void foo3() {
// CIR-BEFORE-IMPROVED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(improved) : !cir.complex<!cir.float>
-// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-IMPROVED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-IMPROVED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-IMPROVED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -540,9 +540,9 @@ void foo3() {
// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(promoted) : !cir.complex<!cir.float>
-// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-PROMOTED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-PROMOTED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-PROMOTED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -639,9 +639,9 @@ void foo3() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -700,9 +700,9 @@ void foo4() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!s32i>
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!s32i> -> !s32i
@@ -780,9 +780,9 @@ void foo5() {
float _Complex c = a / b;
}
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b"]
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -828,9 +828,9 @@ void foo6() {
// CIR-BEFORE-BASIC: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(basic) : !cir.complex<!cir.float>
-// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-BASIC: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-BASIC: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-BASIC: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -903,9 +903,9 @@ void foo6() {
// CIR-BEFORE-IMPROVED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(improved) : !cir.complex<!cir.float>
-// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-IMPROVED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-IMPROVED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-IMPROVED: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -1033,9 +1033,9 @@ void foo6() {
// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(promoted) : !cir.complex<!cir.float>
-// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-PROMOTED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-PROMOTED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-PROMOTED: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -1129,9 +1129,9 @@ void foo6() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -1189,9 +1189,9 @@ void foo7() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!s32i>
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-COMBINED: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/CodeGen/complex-plus-minus.cpp b/clang/test/CIR/CodeGen/complex-plus-minus.cpp
index fbb0335106f88..2a5e644476494 100644
--- a/clang/test/CIR/CodeGen/complex-plus-minus.cpp
+++ b/clang/test/CIR/CodeGen/complex-plus-minus.cpp
@@ -11,8 +11,8 @@ void foo() {
int _Complex c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[ADD:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!s32i>
@@ -54,8 +54,8 @@ void foo2() {
float _Complex c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[ADD:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
@@ -98,10 +98,10 @@ void foo3() {
float _Complex d = (a + b) + c;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c"]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["d", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "d" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[ADD_A_B:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
@@ -165,8 +165,8 @@ void foo4() {
int _Complex c = a - b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[SUB:.*]] = cir.complex.sub %[[TMP_A]], %[[TMP_B]] : !cir.complex<!s32i>
@@ -210,8 +210,8 @@ void foo5() {
float _Complex c = a - b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[SUB:.*]] = cir.complex.sub %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
@@ -254,10 +254,10 @@ void foo6() {
float _Complex d = (a - b) - c;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c"]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["d", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "d" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[SUB_A_B:.*]] = cir.complex.sub %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
diff --git a/clang/test/CIR/CodeGen/complex-unary.cpp b/clang/test/CIR/CodeGen/complex-unary.cpp
index 753b322c6597a..ce895307d5fae 100644
--- a/clang/test/CIR/CodeGen/complex-unary.cpp
+++ b/clang/test/CIR/CodeGen/complex-unary.cpp
@@ -10,14 +10,14 @@ void foo() {
int _Complex b = ~a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-BEFORE: %[[COMPLEX_NOT:.*]] = cir.not %[[TMP]] : !cir.complex<!s32i>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!s32i> -> !s32i
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!s32i> -> !s32i
@@ -52,14 +52,14 @@ void foo2() {
float _Complex b = ~a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_NOT:.*]] = cir.not %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -94,15 +94,15 @@ void foo3() {
float _Complex b = a++;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_INC:.*]] = cir.inc %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -143,15 +143,15 @@ void foo4() {
float _Complex b = ++a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_INC:.*]] = cir.inc %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -192,15 +192,15 @@ void foo5() {
float _Complex b = a--;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_DEC:.*]] = cir.dec %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -241,15 +241,15 @@ void foo6() {
float _Complex b = --a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_DEC:.*]] = cir.dec %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -290,13 +290,13 @@ void foo7() {
float _Complex b = +a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -321,14 +321,14 @@ void foo8() {
float _Complex b = -a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_MINUS:.*]] = cir.minus %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_MINUS]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -367,15 +367,15 @@ void foo9() {
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-BEFORE: %[[A_COMPLEX_F32:.*]] = cir.cast float_complex %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.complex<!cir.float>
// CIR-BEFORE: %[[A_COMPLEX_F16:.*]] = cir.cast float_complex %[[A_COMPLEX_F32]] : !cir.complex<!cir.float> -> !cir.complex<!cir.f16>
// CIR-BEFORE: cir.store{{.*}} %[[A_COMPLEX_F16]], %[[B_ADDR]] : !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
@@ -422,16 +422,16 @@ void foo10() {
_Float16 _Complex b = -a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["b", init]
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-BEFORE: %[[A_COMPLEX_F32:.*]] = cir.cast float_complex %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.complex<!cir.float>
// CIR-BEFORE: %[[RESULT:.*]] = cir.minus %[[A_COMPLEX_F32]] : !cir.complex<!cir.float>
// CIR-BEFORE: %[[A_COMPLEX_F16:.*]] = cir.cast float_complex %[[RESULT]] : !cir.complex<!cir.float> -> !cir.complex<!cir.f16>
// CIR-BEFORE: cir.store{{.*}} %[[A_COMPLEX_F16]], %[[B_ADDR]] : !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["b", init]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
@@ -492,12 +492,12 @@ void complex_unary_inc_lvalue() {
}
-// CIR-BEFORE: %[[A_ADDR]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR-BEFORE: %[[A_ADDR]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[RESULT:.*]] = cir.inc %[[TMP_A]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[RESULT]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -530,12 +530,12 @@ void complex_unary_dec_lvalue() {
--a;
}
-// CIR-BEFORE: %[[A_ADDR]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR-BEFORE: %[[A_ADDR]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[RESULT:.*]] = cir.dec %[[TMP_A]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[RESULT]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex.cpp b/clang/test/CIR/CodeGen/complex.cpp
index ac5394cbcd8f2..3c4fc441f7b8a 100644
--- a/clang/test/CIR/CodeGen/complex.cpp
+++ b/clang/test/CIR/CodeGen/complex.cpp
@@ -30,7 +30,7 @@ float _Complex cf2 = { 1.0f, 2.0f };
void foo() { int _Complex c = {}; }
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.zero : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -45,7 +45,7 @@ void foo() { int _Complex c = {}; }
void foo2() { int _Complex c = {1, 2}; }
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -64,7 +64,7 @@ void foo3() {
int _Complex c = {a, b};
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[TMP_B]] : !s32i -> !cir.complex<!s32i>
@@ -90,7 +90,7 @@ void foo4() {
int _Complex c = {1, a};
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[CONST_1]], %[[TMP_A]] : !s32i -> !cir.complex<!s32i>
@@ -112,7 +112,7 @@ void foo5() {
float _Complex c = {1.0f, 2.0f};
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -131,7 +131,7 @@ void foo6() {
float _Complex c = {a, b};
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[TMP_B]] : !cir.float -> !cir.complex<!cir.float>
@@ -157,7 +157,7 @@ void foo7() {
float _Complex c = {a, 2.0f};
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[CONST_2F:.*]] = cir.const #cir.fp<2.000000e+00> : !cir.float
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[CONST_2F]] : !cir.float -> !cir.complex<!cir.float>
@@ -195,7 +195,7 @@ void foo9(double a, double b) {
double _Complex c = __builtin_complex(a, b);
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c", init]
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.double>, !cir.double
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.double>, !cir.double
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[TMP_B]] : !cir.double -> !cir.complex<!cir.double>
@@ -221,7 +221,7 @@ void foo10() {
double *realPtr = &__real__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[REAL_PTR:.*]] = cir.complex.real_ptr %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
// LLVM: %[[COMPLEX:.*]] = alloca { double, double }, i64 1, align 8
@@ -235,7 +235,7 @@ void foo11() {
double *imagPtr = &__imag__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[IMAG_PTR:.*]] = cir.complex.imag_ptr %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
// LLVM: %[[COMPLEX:.*]] = alloca { double, double }, i64 1, align 8
@@ -249,8 +249,8 @@ void foo12() {
double imag = __imag__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"]
-// CIR: %[[INIT:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["imag", init]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "imag" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[IMAG]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -272,8 +272,8 @@ void foo13() {
double real = __real__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"]
-// CIR: %[[INIT:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["real", init]
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "real" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[REAL]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -311,8 +311,8 @@ void foo15() {
int _Complex b = a;
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[COMPLEX_B]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -336,7 +336,7 @@ int foo16(int _Complex a, int _Complex b) {
return __imag__ a + __imag__ b;
}
-// CIR: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[COMPLEX_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[COMPLEX_A]] : !cir.complex<!s32i> -> !s32i
// CIR: %[[COMPLEX_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -369,7 +369,7 @@ int foo17(int _Complex a, int _Complex b) {
return __real__ a + __real__ b;
}
-// CIR: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[COMPLEX_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[COMPLEX_A]] : !cir.complex<!s32i> -> !s32i
// CIR: %[[COMPLEX_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -548,9 +548,9 @@ void foo22(int _Complex a, int _Complex b) {
int _Complex c = (a, b);
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a", init]
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[COMPLEX_B]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP_B]], %[[RESULT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -577,10 +577,10 @@ void foo23(int _Complex a, int _Complex b) {
int _Complex c = _Generic(a, int _Complex: b, default: f);
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a", init]
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
-// CIR: %[[COMPLEX_F:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["f"]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_F:.*]] = cir.alloca "f" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX_B]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP]], %[[RESULT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -609,8 +609,8 @@ void foo24() {
int _Complex r = arr[1];
}
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!cir.complex<!s32i> x 2>, !cir.ptr<!cir.array<!cir.complex<!s32i> x 2>>, ["arr"]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["r", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} !cir.array<!cir.complex<!s32i> x 2> -> !cir.ptr<!cir.array<!cir.complex<!s32i> x 2>>
+// CIR: %[[RESULT:.*]] = cir.alloca "r" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[RESULT_VAL:.*]] = cir.get_element %[[ARR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!cir.complex<!s32i> x 2>> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[RESULT_VAL]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -640,7 +640,7 @@ void foo25() {
template_foo<__builtin_complex(1.0, 2.0)>();
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["C", init]
+// CIR: %[[INIT:.*]] = cir.alloca "C" {{.*}} init !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.double, #cir.fp<2.000000e+00> : !cir.double> : !cir.complex<!cir.double>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
@@ -657,8 +657,8 @@ void foo26(int _Complex* a) {
int _Complex b = *a;
}
-// CIR: %[[COMPLEX_A_PTR:.*]] = cir.alloca !cir.ptr<!cir.complex<!s32i>>, !cir.ptr<!cir.ptr<!cir.complex<!s32i>>>, ["a", init]
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
+// CIR: %[[COMPLEX_A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!cir.ptr<!cir.complex<!s32i>>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX_A:.*]] = cir.load deref {{.*}} %[[COMPLEX_A_PTR]] : !cir.ptr<!cir.ptr<!cir.complex<!s32i>>>, !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP]], %[[COMPLEX_B]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -685,10 +685,10 @@ void foo27(bool cond, int _Complex a, int _Complex b) {
int _Complex c = cond ? a : b;
}
-// CIR: %[[COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cond", init]
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a", init]
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_COND:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[RESULT_VAL:.*]] = cir.ternary(%[[TMP_COND]], true {
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -748,7 +748,7 @@ void foo28() {
int _Complex a = IntComplex();
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a", init]
+// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.zero : !cir.complex<!s32i>
// CIR: cir.store align(4) %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -766,7 +766,7 @@ void foo29() {
int _Complex a = IntComplex{};
}
-// CIR: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a", init]
+// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.zero : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -783,7 +783,7 @@ void foo30() {
float _Complex a = { 1.0f };
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[CONST_1F:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CIR: %[[CONST_0F:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[CONST_1F]], %[[CONST_0F]] : !cir.float -> !cir.complex<!cir.float>
@@ -807,8 +807,8 @@ void foo31() {
int r = __real__ w.c;
}
-// CIR: %[[W_ADDR:.*]] = cir.alloca !rec_Wrapper, !cir.ptr<!rec_Wrapper>, ["w"]
-// CIR: %[[REAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["r", init]
+// CIR: %[[W_ADDR:.*]] = cir.alloca "w" {{.*}} !rec_Wrapper -> !cir.ptr<!rec_Wrapper>
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[ELEM_PTR:.*]] = cir.get_member %[[W_ADDR]][0] {name = "c"} : !cir.ptr<!rec_Wrapper> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_ELEM_PTR:.*]] = cir.load{{.*}} %[[ELEM_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP_ELEM_PTR]] : !cir.complex<!s32i> -> !s32i
@@ -837,7 +837,7 @@ void foo32() {
int r = __real__ con.c;
}
-// CIR: %[[REAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["r", init]
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[ELEM_PTR:.*]] = cir.get_global @_ZN9Container1cE : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[ELEM:.*]] = cir.load{{.*}} %[[ELEM_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[REAL:.*]] = cir.complex.real %[[ELEM]] : !cir.complex<!s32i> -> !s32i
@@ -856,8 +856,8 @@ void foo33(__builtin_va_list a) {
float _Complex b = __builtin_va_arg(a, float _Complex);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!rec___va_list_tag>, !cir.ptr<!cir.ptr<!rec___va_list_tag>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!rec___va_list_tag> -> !cir.ptr<!cir.ptr<!rec___va_list_tag>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.ptr<!rec___va_list_tag>, !cir.ptr<!cir.ptr<!rec___va_list_tag>>
// CIR: %[[VA_TAG:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!rec___va_list_tag>>, !cir.ptr<!rec___va_list_tag>
// CIR: %[[COMPLEX:.*]] = cir.va_arg %[[VA_TAG]] : (!cir.ptr<!rec___va_list_tag>) -> !cir.complex<!cir.float>
@@ -913,7 +913,7 @@ void foo34() {
__c11_atomic_init(&a, {1.0f, 2.0f});
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[CONST_COMPLEX:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[CONST_COMPLEX]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -931,8 +931,8 @@ void foo35() {
_Float16 real = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR: %[[REAL_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["real", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca "real" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// 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
@@ -968,8 +968,8 @@ void foo36() {
_Float16 imag = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR: %[[IMAG_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["imag", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[IMAG_ADDR:.*]] = cir.alloca "imag" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// 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
@@ -1005,8 +1005,8 @@ void foo37() {
_Complex float b = __extension__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -1031,8 +1031,8 @@ void real_on_non_glvalue() {
float b = __real__(+a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR: cir.store{{.*}} %[[RESULT_REAL]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1056,8 +1056,8 @@ void imag_on_non_glvalue() {
float b = __imag__(+a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR: cir.store{{.*}} %[[RESULT_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1081,9 +1081,9 @@ void atomic_complex_type() {
float _Complex b = __c11_atomic_load(&a, __ATOMIC_RELAXED);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR: %[[ATOMIC_TMP_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["atomic-temp"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ATOMIC_TMP_ADDR:.*]] = cir.alloca "atomic-temp" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[A_PTR:.*]] = cir.cast bitcast %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!u64i>
// CIR: %[[ATOMIC_TMP_PTR:.*]] = cir.cast bitcast %[[ATOMIC_TMP_ADDR]] : !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!u64i>
// CIR: %[[TMP_A_ATOMIC:.*]] = cir.load{{.*}} atomic(relaxed) %[[A_PTR]] : !cir.ptr<!u64i>, !u64i
@@ -1119,8 +1119,8 @@ void real_on_scalar_glvalue() {
float b = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.float -> !cir.float
// CIR: cir.store{{.*}} %[[A_REAL]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1140,8 +1140,8 @@ void imag_on_scalar_glvalue() {
float b = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.float -> !cir.float
// CIR: cir.store{{.*}} %[[A_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1159,8 +1159,8 @@ void real_on_scalar_with_type_promotion() {
_Float16 b = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CIR: %[[TMP_A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A_F32]] : !cir.float -> !cir.float
@@ -1186,8 +1186,8 @@ void imag_on_scalar_with_type_promotion() {
_Float16 b = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// CIR: %[[TMP_A:.*]] = cir.load %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.f16 -> !cir.f16
// CIR: %[[A_IMAG_F16:.*]] = cir.cast floating %[[A_IMAG]] : !cir.f16 -> !cir.f16
@@ -1206,8 +1206,8 @@ void imag_on_const_scalar() {
float b = __imag__ 1.0f;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[CONST_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CIR: %[[CONST_IMAG:.*]] = cir.complex.imag %[[CONST_ONE]] : !cir.float -> !cir.float
// CIR: cir.store{{.*}} %[[CONST_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1225,8 +1225,8 @@ void real_on_scalar_from_real_with_type_promotion() {
_Float16 b = __real__(__real__ a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// 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
@@ -1263,8 +1263,8 @@ void real_on_scalar_from_imag_with_type_promotion() {
_Float16 b = __real__(__imag__ a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// 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
@@ -1298,7 +1298,7 @@ void real_on_scalar_from_imag_with_type_promotion() {
void complex_type_parameter(float _Complex a) {}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// TODO(CIR): the difference between the CIR LLVM and OGCG is because the lack of calling convention lowering,
@@ -1315,8 +1315,8 @@ void complex_type_argument() {
complex_type_parameter(a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[ARG_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["coerce"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[ARG_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_ARG:.*]] = cir.load{{.*}} %[[ARG_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1346,7 +1346,7 @@ float _Complex complex_type_return_type() {
return { 1.0f, 2.0f };
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["__retval"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[RET_VAL:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[RET_VAL]], %[[RET_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_RET:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1371,8 +1371,8 @@ void real_on_scalar_bool() {
bool b = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.bool -> !cir.bool
// CIR: cir.store{{.*}} %[[A_REAL]], %[[B_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -1396,8 +1396,8 @@ void imag_on_scalar_bool() {
bool b = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.bool -> !cir.bool
// CIR: cir.store{{.*}} %[[A_IMAG]], %[[B_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -1415,7 +1415,7 @@ void imag_on_scalar_bool() {
void function_with_complex_default_arg(
float _Complex a = __builtin_complex(1.0f, 2.2f)) {}
-// CIR: %[[ARG_0_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
+// CIR: %[[ARG_0_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %{{.*}}, %[[ARG_0_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// TODO(CIR): the difference between the CIR LLVM and OGCG is because the lack of calling convention lowering,
@@ -1430,7 +1430,7 @@ void calling_function_with_default_arg() {
function_with_complex_default_arg();
}
-// CIR: %[[DEFAULT_ARG_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["coerce"]
+// CIR: %[[DEFAULT_ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[DEFAULT_ARG_VAL:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.200000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[DEFAULT_ARG_VAL]], %[[DEFAULT_ARG_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_DEFAULT_ARG:.*]] = cir.load{{.*}} %[[DEFAULT_ARG_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1455,7 +1455,7 @@ void calling_function_that_return_complex() {
float _Complex a = complex_type_return_type();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[RESULT:.*]] = cir.call @_Z24complex_type_return_typev() : () -> (!cir.complex<!cir.float> {llvm.noundef})
// CIR: cir.store{{.*}} %[[RESULT]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -1484,9 +1484,9 @@ void imag_literal_gnu_extension() {
int _Complex c = 3i;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX_A:.*]] = cir.const #cir.const_complex<#cir.fp<0.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[COMPLEX_A]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[COMPLEX_B:.*]] = cir.const #cir.const_complex<#cir.fp<0.000000e+00> : !cir.double, #cir.fp<3.000000e+00> : !cir.double> : !cir.complex<!cir.double>
@@ -1527,10 +1527,10 @@ void load_store_volatile() {
c = d;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c"]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["d"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_B:.*]] = cir.load volatile {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: cir.store volatile {{.*}} %[[TMP_B]], %[[A_ADDR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[TMP_D:.*]] = cir.load volatile {{.*}} %[[D_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -1585,14 +1585,14 @@ void load_store_volatile_2() {
dv = d;
}
-// CIR: %[[AV_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["av"]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["b"]
-// CIR: %[[BV_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["bv"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c"]
-// CIR: %[[CV_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["cv"]
-// CIR: %[[DV_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["dv"]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["d"]
+// CIR: %[[AV_ADDR:.*]] = cir.alloca "av" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[BV_ADDR:.*]] = cir.alloca "bv" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[CV_ADDR:.*]] = cir.alloca "cv" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[DV_ADDR:.*]] = cir.alloca "dv" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: cir.store volatile {{.*}} %[[TMP_A]], %[[AV_ADDR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[TMP_BV:.*]] = cir.load volatile {{.*}} %[[BV_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
@@ -1664,9 +1664,9 @@ bool eq_float_complex_and_float(float _Complex a, float b) {
return a == b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1712,9 +1712,9 @@ bool eq_float_and_float_complex(float a, float _Complex b) {
return a == b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
@@ -1760,9 +1760,9 @@ bool ne_float_complex_and_float(float _Complex a, float b) {
return a != b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1808,9 +1808,9 @@ bool ne_float_and_float_complex(float a, float _Complex b) {
return a != b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
@@ -1858,9 +1858,9 @@ void compare_two_complex_bin_ops() {
bool c = a + b != b + a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[COMPLEX_AB:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.double>
diff --git a/clang/test/CIR/CodeGen/compound_literal.cpp b/clang/test/CIR/CodeGen/compound_literal.cpp
index cb130ffa920e4..f01f2b9777a7f 100644
--- a/clang/test/CIR/CodeGen/compound_literal.cpp
+++ b/clang/test/CIR/CodeGen/compound_literal.cpp
@@ -13,9 +13,9 @@ int foo() {
// CIR-DAG: cir.global "private" constant cir_private @[[FOO4_P:.*]] = #cir.const_record<{#cir.int<5> : !s32i, #cir.int<10> : !s32i}> : !rec_Point
// LLVM-DAG: @[[FOO4_P:.*]] = private constant %struct.Point { i32 5, i32 10 }
-// CIR: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
-// CIR: %[[COMPOUND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, [".compoundliteral", init]
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[COMPOUND:.*]] = cir.alloca ".compoundliteral" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VALUE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[VALUE]], %[[COMPOUND]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPOUND]] : !cir.ptr<!s32i>, !s32i
@@ -48,8 +48,8 @@ void foo2() {
int _Complex a = (int _Complex) { 1, 2};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a", init]
-// CIR: %[[CL_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, [".compoundliteral"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[CL_ADDR:.*]] = cir.alloca ".compoundliteral" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[CL_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[CL_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -81,7 +81,7 @@ void foo3() {
auto a = (vi4){10, 20, 30, 40};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC:.*]] = cir.const #cir.const_vector<[#cir.int<10> : !s32i, #cir.int<20> : !s32i, #cir.int<30> : !s32i, #cir.int<40> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC]], %[[A_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -109,7 +109,7 @@ void foo4() {
}
// CIR-LABEL: @_Z4foo4v
-// CIR: %[[P:.*]] = cir.alloca !rec_Point, !cir.ptr<!rec_Point>, ["p", init]
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
// CIR: %[[CONST:.*]] = cir.get_global @[[FOO4_P]] : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[CONST]] to %[[P]] : !cir.ptr<!rec_Point>
diff --git a/clang/test/CIR/CodeGen/concept-specialization.cpp b/clang/test/CIR/CodeGen/concept-specialization.cpp
index e1fa2b831b12f..6792b5d31809b 100644
--- a/clang/test/CIR/CodeGen/concept-specialization.cpp
+++ b/clang/test/CIR/CodeGen/concept-specialization.cpp
@@ -10,7 +10,7 @@ concept C = sizeof(T) % 2 == 0;
void concept_specialization() { bool a = C<int>; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.store {{.*}} %[[CONST_TRUE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
diff --git a/clang/test/CIR/CodeGen/constant-expr.cpp b/clang/test/CIR/CodeGen/constant-expr.cpp
index 492cfc5b8fbe2..fa8fccaf6c53f 100644
--- a/clang/test/CIR/CodeGen/constant-expr.cpp
+++ b/clang/test/CIR/CodeGen/constant-expr.cpp
@@ -18,9 +18,9 @@ void calling_consteval_methods() {
a.consteval_ret_void();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_StructWithConstEval, !cir.ptr<!rec_StructWithConstEval>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithConstEval -> !cir.ptr<!rec_StructWithConstEval>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store {{.*}} %[[CONST_1]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[CONST_COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
diff --git a/clang/test/CIR/CodeGen/copy-constructor.cpp b/clang/test/CIR/CodeGen/copy-constructor.cpp
index 4d0e5d8933cc1..3308dfa7defd2 100644
--- a/clang/test/CIR/CodeGen/copy-constructor.cpp
+++ b/clang/test/CIR/CodeGen/copy-constructor.cpp
@@ -13,8 +13,8 @@ struct HasScalarArrayMember {
HasScalarArrayMember::HasScalarArrayMember(const HasScalarArrayMember &) = default;
// CIR-LABEL: cir.func {{.*}} @_ZN20HasScalarArrayMemberC2ERKS_(
-// CIR-NEXT: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_HasScalarArrayMember>
-// CIR-NEXT: %[[OTHER:.*]] = cir.alloca !cir.ptr<!rec_HasScalarArrayMember>
+// CIR-NEXT: %[[THIS:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_HasScalarArrayMember>
+// CIR-NEXT: %[[OTHER:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_HasScalarArrayMember>
// CIR-NEXT: cir.store %arg0, %[[THIS]]
// CIR-NEXT: cir.store %arg1, %[[OTHER]]
// CIR-NEXT: %[[THIS_LOAD:.*]] = cir.load{{.*}} %[[THIS]]
diff --git a/clang/test/CIR/CodeGen/coro-task.cpp b/clang/test/CIR/CodeGen/coro-task.cpp
index bb62cf278189c..7abaabedd4a27 100644
--- a/clang/test/CIR/CodeGen/coro-task.cpp
+++ b/clang/test/CIR/CodeGen/coro-task.cpp
@@ -150,12 +150,12 @@ VoidTask silly_task() {
}
// CIR: cir.func coroutine {{.*}} @_Z10silly_taskv() -> ![[VoidTask]]
-// CIR: %[[VoidTaskAddr:.*]] = cir.alloca ![[VoidTask]], {{.*}}, ["__retval"]
-// CIR: %[[SavedFrameAddr:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__coro_frame_addr"]
-// CIR: %[[VoidPromisseAddr:.*]] = cir.alloca ![[VoidPromisse]], {{.*}}, ["__promise"]
-// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca ![[SuspendAlways]], {{.*}} ["ref.tmp0"]
-// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca ![[CoroHandleVoid]], {{.*}} ["agg.tmp0"]
-// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca ![[CoroHandlePromiseVoid]], {{.*}} ["agg.tmp1"]
+// CIR: %[[VoidTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]] -> {{.*}}
+// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[VoidPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]] -> {{.*}}
+// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
+// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
+// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]]
// OGCG: %[[VoidPromisseAddr:.*]] = alloca %[[VoidPromisse]], align 1
// OGCG: %[[VoidTaskAddr:.*]] = alloca %[[VoidTask]], align 1
@@ -351,14 +351,14 @@ folly::coro::Task<int> byRef(const std::string& s) {
}
// CIR: cir.func coroutine {{.*}} @_Z5byRefRKSt6string(%[[ARG:.*]]: !cir.ptr<![[StdString]]> {{.*}}) -> ![[IntTask]]
-// CIR: %[[AllocaParam:.*]] = cir.alloca !cir.ptr<![[StdString]]>, {{.*}}, ["s", init, const]
-// CIR: %[[IntTaskAddr:.*]] = cir.alloca ![[IntTask]], {{.*}}, ["__retval"]
-// CIR: %[[SavedFrameAddr:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__coro_frame_addr"]
-// CIR: %[[AllocaFnUse:.*]] = cir.alloca !cir.ptr<![[StdString]]>, {{.*}}, ["s", init, const]
-// CIR: %[[IntPromisseAddr:.*]] = cir.alloca ![[IntPromisse]], {{.*}}, ["__promise"]
-// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca ![[SuspendAlways]], {{.*}} ["ref.tmp0"] {alignment = 1 : i64}
-// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca ![[CoroHandleVoid]], {{.*}} ["agg.tmp0"] {alignment = 1 : i64}
-// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca ![[CoroHandlePromiseInt]], {{.*}} ["agg.tmp1"] {alignment = 1 : i64}
+// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]> -> {{.*}}
+// CIR: %[[IntTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[IntTask]] -> {{.*}}
+// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[AllocaFnUse:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]> -> {{.*}}
+// CIR: %[[IntPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[IntPromisse]] -> {{.*}}
+// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
+// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
+// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseInt]]
// CIR: cir.store %[[ARG]], %[[AllocaParam]] : !cir.ptr<![[StdString]]>, {{.*}}
// CIR: cir.cleanup.scope {
@@ -442,20 +442,20 @@ folly::coro::Task<void> yield1() {
// CIR: cir.func coroutine {{.*}} @_Z6yield1v() -> !rec_folly3A3Acoro3A3ATask3Cvoid3E
// Prologue allocas (still present in output)
-// CIR-DAG: %[[RETVAL:.*]] = cir.alloca ![[VoidTask]], {{.*}} ["__retval"]
-// CIR-DAG: %[[FRAME:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__coro_frame_addr"]
-// CIR-DAG: %[[PROMISE:.*]] = cir.alloca ![[VoidPromisse]], {{.*}} ["__promise"]
-// CIR-DAG: %[[SUSP0:.*]] = cir.alloca ![[SuspendAlways]], {{.*}} ["ref.tmp0"]
-// CIR-DAG: %[[CH_VOID0:.*]] = cir.alloca ![[CoroHandleVoid]], {{.*}} ["agg.tmp0"]
-// CIR-DAG: %[[CH_PROM0:.*]] = cir.alloca ![[CoroHandlePromiseVoid]], {{.*}} ["agg.tmp1"]
-// CIR-DAG: %[[T_ADDR:.*]] = cir.alloca ![[VoidTask]], {{.*}} ["t", init]
-// CIR-DAG: %[[SUSP1:.*]] = cir.alloca ![[SuspendAlways]], {{.*}} ["ref.tmp1"]
-// CIR-DAG: %[[AWAITER_COPY_ADDR:.*]] = cir.alloca ![[VoidTask]], {{.*}} ["agg.tmp2"]
-// CIR-DAG: %[[CH_VOID1:.*]] = cir.alloca ![[CoroHandleVoid]], {{.*}} ["agg.tmp3"]
-// CIR-DAG: %[[CH_PROM1:.*]] = cir.alloca ![[CoroHandlePromiseVoid]], {{.*}} ["agg.tmp4"]
-// CIR-DAG: %[[SUSP2:.*]] = cir.alloca ![[SuspendAlways]], {{.*}} ["ref.tmp2"]
-// CIR-DAG: %[[CH_VOID2:.*]] = cir.alloca ![[CoroHandleVoid]], {{.*}} ["agg.tmp5"]
-// CIR-DAG: %[[CH_PROM2:.*]] = cir.alloca ![[CoroHandlePromiseVoid]], {{.*}} ["agg.tmp6"]
+// CIR-DAG: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]]
+// CIR-DAG: %[[FRAME:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR-DAG: %[[PROMISE:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]] -> {{.*}}
+// CIR-DAG: %[[SUSP0:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]] -> {{.*}}
+// CIR-DAG: %[[CH_VOID0:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]] -> {{.*}}
+// CIR-DAG: %[[CH_PROM0:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]] -> {{.*}}
+// CIR-DAG: %[[T_ADDR:.*]] = cir.alloca "t" {{.*}} init ![[VoidTask]] -> {{.*}}
+// CIR-DAG: %[[SUSP1:.*]] = cir.alloca "ref.tmp1" {{.*}} ![[SuspendAlways]] -> {{.*}}
+// CIR-DAG: %[[AWAITER_COPY_ADDR:.*]] = cir.alloca "agg.tmp2" {{.*}} ![[VoidTask]] -> {{.*}}
+// CIR-DAG: %[[CH_VOID1:.*]] = cir.alloca "agg.tmp3" {{.*}} ![[CoroHandleVoid]] -> {{.*}}
+// CIR-DAG: %[[CH_PROM1:.*]] = cir.alloca "agg.tmp4" {{.*}} ![[CoroHandlePromiseVoid]] -> {{.*}}
+// CIR-DAG: %[[SUSP2:.*]] = cir.alloca "ref.tmp2" {{.*}} ![[SuspendAlways]] -> {{.*}}
+// CIR-DAG: %[[CH_VOID2:.*]] = cir.alloca "agg.tmp5" {{.*}} ![[CoroHandleVoid]] -> {{.*}}
+// CIR-DAG: %[[CH_PROM2:.*]] = cir.alloca "agg.tmp6" {{.*}} ![[CoroHandlePromiseVoid]] -> {{.*}}
// CIR: cir.cleanup.scope {
// initial_suspend + await(init)
@@ -538,8 +538,8 @@ folly::coro::Task<int> go1() {
}
// CIR: cir.func coroutine {{.*}} @_Z3go1v() {{.*}} ![[IntTask]]
-// CIR: %[[IntTaskAddr:.*]] = cir.alloca ![[IntTask]], !cir.ptr<![[IntTask]]>, ["task", init]
-// CIR: %[[OneAddr:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp1", init] {alignment = 4 : i64}
+// CIR: %[[IntTaskAddr:.*]] = cir.alloca "task" {{.*}} init ![[IntTask]] -> !cir.ptr<![[IntTask]]>
+// CIR: %[[OneAddr:.*]] = cir.alloca "ref.tmp1" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: cir.cleanup.scope {
// CIR: cir.await(init, ready : {
@@ -789,7 +789,7 @@ folly::coro::Task<int> co_return_with_dtor(int flag) {
// CIR: cir.func coroutine {{.*}} @_Z19co_return_with_dtori
-// CIR: %[[LOCAL:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["local"]
+// CIR: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CIR: cir.cleanup.scope {
// CIR: cir.await(init, ready : {
// CIR: }, suspend : {
@@ -851,8 +851,8 @@ folly::coro::Task<int __complex__> complex_co_await() noexcept {
// CIR: cir.func coroutine {{.*}} @_Z16complex_co_awaitv
-// CIR: %[[COMPLEX_ADDR:.*]] = cir.alloca !rec_folly3A3Acoro3A3ATask3C_Complex_int3E, !cir.ptr<!rec_folly3A3Acoro3A3ATask3C_Complex_int3E>, ["ref.tmp1"]
-// CIR: %[[RESUME_VAL_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["__coawait_resume_rval"]
+// CIR: %[[COMPLEX_ADDR:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_folly3A3Acoro3A3ATask3C_Complex_int3E -> !cir.ptr<!rec_folly3A3Acoro3A3ATask3C_Complex_int3E>
+// CIR: %[[RESUME_VAL_ADDR:.*]] = cir.alloca "__coawait_resume_rval" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: cir.cleanup.scope {
// CIR: cir.await(init, ready : {
diff --git a/clang/test/CIR/CodeGen/count-of.c b/clang/test/CIR/CodeGen/count-of.c
index 1fd1290c42e6b..fa849567aadc5 100644
--- a/clang/test/CIR/CodeGen/count-of.c
+++ b/clang/test/CIR/CodeGen/count-of.c
@@ -10,8 +10,8 @@ unsigned long vla_with_array_element_type_with_const_size() {
return _Countof(int[5][size]);
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["__retval"]
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["size"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} !s64i -> !cir.ptr<!s64i>
// CIR: %[[CONST_5:.*]] = cir.const #cir.int<5> : !u64i
// CIR: cir.store %[[CONST_5]], %[[RET_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[RET_VAL:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!u64i>, !u64i
@@ -31,8 +31,8 @@ unsigned long vla_with_array_element_type_non_const_size() {
return _Countof(int[size][size]);
}
-// CIR: %[[REET_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["__retval"]
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["size"]
+// CIR: %[[REET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} !s64i -> !cir.ptr<!s64i>
// CIR: %[[TMP_SIZE:.*]] = cir.load {{.*}} %[[SIZE_ADDR]] : !cir.ptr<!s64i>, !s64i
// CIR: %[[TMP_SIZE_U64:.*]] = cir.cast integral %[[TMP_SIZE]] : !s64i -> !u64i
// CIR: cir.store %[[TMP_SIZE_U64]], %[[RET_ADDR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp b/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp
index 31d2801bd06f4..325e692a879b3 100644
--- a/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp
+++ b/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp
@@ -19,12 +19,12 @@ B::B() {
}
// CHECK: cir.func{{.*}} @_Z3barv()
-// CHECK: %[[B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["b", init]
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
// CHECK: cir.call @_ZN1BC1Ev(%[[B]]) : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CHECK: cir.return
// CHECK: cir.func{{.*}} @_ZN1BC2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["this", init]
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
diff --git a/clang/test/CIR/CodeGen/ctor-alias.cpp b/clang/test/CIR/CodeGen/ctor-alias.cpp
index 2af6684326e82..37ada55878a42 100644
--- a/clang/test/CIR/CodeGen/ctor-alias.cpp
+++ b/clang/test/CIR/CodeGen/ctor-alias.cpp
@@ -16,7 +16,7 @@ B::B() {
// OGCG: @_ZN1BC1Ev = unnamed_addr alias void (ptr), ptr @_ZN1BC2Ev
// CHECK: cir.func{{.*}} @_ZN1BC2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["this", init]
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
@@ -37,7 +37,7 @@ void bar() {
}
// CHECK: cir.func{{.*}} @_Z3barv()
-// CHECK: %[[B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["b", init]
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
// CHECK: cir.call @_ZN1BC1Ev(%[[B]]) : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CHECK: cir.return
@@ -61,7 +61,7 @@ void baz() {
}
// CHECK: cir.func{{.*}} @_ZN5StrukC2Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>, ["this", init]
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK: cir.return
@@ -69,7 +69,7 @@ void baz() {
// CHECK-NOT: cir.func{{.*}} @_ZN5StrukC1Ev
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK: %[[S_ADDR:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s", init]
+// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukC2Ev(%[[S_ADDR]]) : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// LLVM: define linkonce_odr void @_ZN5StrukC2Ev(ptr{{.*}} %[[THIS_ARG]])
diff --git a/clang/test/CIR/CodeGen/ctor-null-init.cpp b/clang/test/CIR/CodeGen/ctor-null-init.cpp
index 6f99cfa084a55..f05ee79b009a9 100644
--- a/clang/test/CIR/CodeGen/ctor-null-init.cpp
+++ b/clang/test/CIR/CodeGen/ctor-null-init.cpp
@@ -18,7 +18,7 @@ void test_empty_base_null_init() {
}
// CIR: cir.func {{.*}} @_Z25test_empty_base_null_initv()
-// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["agg.tmp.ensured"]
+// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_B -> !cir.ptr<!rec_B>
// CIR-NEXT: %[[A_ADDR:.*]] = cir.base_class_addr %[[B_ADDR]] : !cir.ptr<!rec_B> nonnull [0] -> !cir.ptr<!rec_A>
// LLVM: define{{.*}} @_Z25test_empty_base_null_initv()
@@ -45,7 +45,7 @@ void test_non_empty_base_null_init() {
}
// CIR: cir.func {{.*}} @_Z29test_non_empty_base_null_initv()
-// CIR: %[[TMP:.*]] = cir.alloca !rec_D, !cir.ptr<!rec_D>, ["agg.tmp.ensured"]
+// CIR: %[[TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_D -> !cir.ptr<!rec_D>
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TMP]] : !cir.ptr<!rec_D> nonnull [0] -> !cir.ptr<!rec_C>
// CIR: %[[ZERO:.*]] = cir.const #cir.const_record<{#cir.int<0> : !s32i}> : !rec_C
// CIR: cir.store{{.*}} %[[ZERO]], %[[BASE]]
@@ -76,7 +76,7 @@ void test_base_chain_null_init() {
}
// CIR: cir.func {{.*}} @_Z25test_base_chain_null_initv()
-// CIR: %[[TMP:.*]] = cir.alloca !rec_G, !cir.ptr<!rec_G>, ["agg.tmp.ensured"]
+// CIR: %[[TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_G -> !cir.ptr<!rec_G>
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TMP]] : !cir.ptr<!rec_G> nonnull [0] -> !cir.ptr<!rec_F>
// CIR: %[[ZERO:.*]] = cir.const #cir.const_record<{#cir.zero : !rec_E}> : !rec_F
// CIR: cir.store{{.*}} %[[ZERO]], %[[BASE]]
diff --git a/clang/test/CIR/CodeGen/ctor-try-body.cpp b/clang/test/CIR/CodeGen/ctor-try-body.cpp
index 567fe9d7c77ac..4ce798b2efde8 100644
--- a/clang/test/CIR/CodeGen/ctor-try-body.cpp
+++ b/clang/test/CIR/CodeGen/ctor-try-body.cpp
@@ -31,8 +31,8 @@ struct HasThings : Base {
}
// CIR: cir.func {{.*}}@_ZN9HasThingsC2ERK4Ctor(%[[THIS_ARG:.*]]: !cir.ptr<!rec_HasThings> {{.*}}, %[[C_ARG:.*]]: !cir.ptr<!rec_Ctor> {{.*}}) {{.*}}special_member<#cir.cxx_ctor<!rec_HasThings, custom>>{{.*}} {
-// CIR-NEXT: %[[THIS_ALLOC:.*]] = cir.alloca !cir.ptr<!rec_HasThings>, !cir.ptr<!cir.ptr<!rec_HasThings>>, ["this", init]
-// CIR-NEXT: %[[C_ALLOC:.*]] = cir.alloca !cir.ptr<!rec_Ctor>, !cir.ptr<!cir.ptr<!rec_Ctor>>, ["c", init, const]
+// CIR-NEXT: %[[THIS_ALLOC:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasThings> -> !cir.ptr<!cir.ptr<!rec_HasThings>>
+// CIR-NEXT: %[[C_ALLOC:.*]] = cir.alloca "c" {{.*}} init const !cir.ptr<!rec_Ctor> -> !cir.ptr<!cir.ptr<!rec_Ctor>>
// CIR-NEXT: cir.store %[[THIS_ARG]], %[[THIS_ALLOC]] : !cir.ptr<!rec_HasThings>, !cir.ptr<!cir.ptr<!rec_HasThings>>
// CIR-NEXT: cir.store %[[C_ARG]], %[[C_ALLOC]] : !cir.ptr<!rec_Ctor>, !cir.ptr<!cir.ptr<!rec_Ctor>>
// CIR-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOC]] : !cir.ptr<!cir.ptr<!rec_HasThings>>, !cir.ptr<!rec_HasThings>
diff --git a/clang/test/CIR/CodeGen/ctor.cpp b/clang/test/CIR/CodeGen/ctor.cpp
index f5fee879b9cb4..5c8ee3758468e 100644
--- a/clang/test/CIR/CodeGen/ctor.cpp
+++ b/clang/test/CIR/CodeGen/ctor.cpp
@@ -17,20 +17,20 @@ void baz() {
// NYI, but when it is added this test should be updated to add a RUN
// line that passes '-mconstructor-aliases' to clang_cc1.
// CHECK: cir.func{{.*}} @_ZN5StrukC2Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN5StrukC1Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>, ["this", init] {alignment = 8 : i64}
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK-NEXT: cir.call @_ZN5StrukC2Ev(%[[THIS]]) : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s", init] {alignment = 4 : i64}
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" align(4) init !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK-NEXT: cir.call @_ZN5StrukC1Ev(%[[S_ADDR]]) : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK-NEXT: cir.return
@@ -50,8 +50,8 @@ void bar() {
// CHECK: cir.func{{.*}} @_ZN13VariadicStrukC1Eiz(%arg0: !cir.ptr<!rec_VariadicStruk>
// CHECK-SAME: %arg1: !s32i
// CHECK-SAME: ...){{.*}} {
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca {{.*}} ["n", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[N_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -61,7 +61,7 @@ void bar() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z3barv
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca !rec_VariadicStruk, !cir.ptr<!rec_VariadicStruk>, ["s", init]
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init !rec_VariadicStruk -> !cir.ptr<!rec_VariadicStruk>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
@@ -80,8 +80,8 @@ void bam() {
// CHECK: cir.func{{.*}} @_ZN15DelegatingStrukC2Ei(%arg0: !cir.ptr<!rec_DelegatingStruk>
// CHECK-SAME: %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca {{.*}} ["n", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[N_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -92,8 +92,8 @@ void bam() {
// CHECK: cir.func{{.*}} @_ZN15DelegatingStrukC1Ei(%arg0: !cir.ptr<!rec_DelegatingStruk>
// CHECK-SAME: %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca {{.*}} ["n", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[N_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -102,7 +102,7 @@ void bam() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN15DelegatingStrukC1Ev(%arg0: !cir.ptr<!rec_DelegatingStruk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -110,7 +110,7 @@ void bam() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z3bamv
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca {{.*}} ["s", init]
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init
// CHECK-NEXT: cir.call @_ZN15DelegatingStrukC1Ev(%[[S_ADDR]])
// CHECK-NEXT: cir.return
@@ -124,7 +124,7 @@ void init_member() {
}
// CHECK: cir.func{{.*}} @_ZN15MemberInitStrukC2Ev(%arg0: !cir.ptr<!rec_MemberInitStruk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CHECK-NEXT: %[[A_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "a"}
@@ -133,14 +133,14 @@ void init_member() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN15MemberInitStrukC1Ev(%arg0: !cir.ptr<!rec_MemberInitStruk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CHECK-NEXT: cir.call @_ZN15MemberInitStrukC2Ev(%[[THIS]])
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z11init_memberv
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca {{.*}} ["s", init]
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init
// CHECK-NEXT: cir.call @_ZN15MemberInitStrukC1Ev(%[[S_ADDR]])
// CHECK-NEXT: cir.return
@@ -155,8 +155,8 @@ void init_param_member() {
// CHECK: cir.func{{.*}} @_ZN20ParamMemberInitStrukC2Ei(%arg0: !cir.ptr<!rec_ParamMemberInitStruk>
// CHECK-SAME: %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca {{.*}} ["n", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[N_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -167,8 +167,8 @@ void init_param_member() {
// CHECK: cir.func{{.*}} @_ZN20ParamMemberInitStrukC1Ei(%arg0: !cir.ptr<!rec_ParamMemberInitStruk>
// CHECK-SAME: %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca {{.*}} ["n", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[N_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -177,7 +177,7 @@ void init_param_member() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z17init_param_memberv
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca {{.*}} ["s", init]
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0>
// CHECK-NEXT: cir.call @_ZN20ParamMemberInitStrukC1Ei(%[[S_ADDR]], %[[ZERO]])
// CHECK-NEXT: cir.return
@@ -198,7 +198,7 @@ void init_union() {
}
// CHECK: cir.func{{.*}} @_ZN14UnionInitStrukC2Ev(%arg0: !cir.ptr<!rec_UnionInitStruk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CHECK-NEXT: %[[AU1_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = ""}
@@ -209,14 +209,14 @@ void init_union() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN14UnionInitStrukC1Ev(%arg0: !cir.ptr<!rec_UnionInitStruk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CHECK-NEXT: cir.call @_ZN14UnionInitStrukC2Ev
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z10init_unionv
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca {{.*}} ["s", init]
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init
// CHECK-NEXT: cir.call @_ZN14UnionInitStrukC1Ev(%[[S_ADDR]])
// CHECK-NEXT: cir.return
@@ -234,8 +234,8 @@ void test_derived() {
}
// CHECK: cir.func{{.*}} @_ZN4BaseC2Ei(%arg0: !cir.ptr<!rec_Base> {{.*}}, %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca {{.*}} ["val", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca "val" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -245,8 +245,8 @@ void test_derived() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN7DerivedC2Ei(%arg0: !cir.ptr<!rec_Derived> {{.*}}, %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca {{.*}} ["val", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca "val" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -256,8 +256,8 @@ void test_derived() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN7DerivedC1Ei(%arg0: !cir.ptr<!rec_Derived> {{.*}}, %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca {{.*}} ["val", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca "val" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -266,7 +266,7 @@ void test_derived() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z12test_derivedv
-// CHECK-NEXT: %[[D_ADDR:.*]] = cir.alloca {{.*}} ["d", init]
+// CHECK-NEXT: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.call @_ZN7DerivedC1Ei(%[[D_ADDR]], %[[ONE]])
// CHECK-NEXT: cir.return
@@ -286,8 +286,8 @@ void test_derived2() {
}
// CHECK: cir.func{{.*}} @_ZN5Base2C2Ei(%arg0: !cir.ptr<!rec_Base2> {{.*}}, %arg1: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca {{.*}} ["val", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[VAL_ADDR:.*]] = cir.alloca "val" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -300,10 +300,10 @@ void test_derived2() {
// CHECK-SAME: %arg1: !s32i
// CHECK-SAME: %arg2: !s32i
// CHECK-SAME: %arg3: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[VAL1_ADDR:.*]] = cir.alloca {{.*}} ["val1", init]
-// CHECK-NEXT: %[[VAL2_ADDR:.*]] = cir.alloca {{.*}} ["val2", init]
-// CHECK-NEXT: %[[VAL3_ADDR:.*]] = cir.alloca {{.*}} ["val3", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[VAL1_ADDR:.*]] = cir.alloca "val1" {{.*}} init
+// CHECK-NEXT: %[[VAL2_ADDR:.*]] = cir.alloca "val2" {{.*}} init
+// CHECK-NEXT: %[[VAL3_ADDR:.*]] = cir.alloca "val3" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL1_ADDR]]
// CHECK-NEXT: cir.store %arg2, %[[VAL2_ADDR]]
@@ -324,10 +324,10 @@ void test_derived2() {
// CHECK-SAME: %arg1: !s32i
// CHECK-SAME: %arg2: !s32i
// CHECK-SAME: %arg3: !s32i
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CHECK-NEXT: %[[VAL1_ADDR:.*]] = cir.alloca {{.*}} ["val1", init]
-// CHECK-NEXT: %[[VAL2_ADDR:.*]] = cir.alloca {{.*}} ["val2", init]
-// CHECK-NEXT: %[[VAL3_ADDR:.*]] = cir.alloca {{.*}} ["val3", init]
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CHECK-NEXT: %[[VAL1_ADDR:.*]] = cir.alloca "val1" {{.*}} init
+// CHECK-NEXT: %[[VAL2_ADDR:.*]] = cir.alloca "val2" {{.*}} init
+// CHECK-NEXT: %[[VAL3_ADDR:.*]] = cir.alloca "val3" {{.*}} init
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL1_ADDR]]
// CHECK-NEXT: cir.store %arg2, %[[VAL2_ADDR]]
@@ -340,7 +340,7 @@ void test_derived2() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z13test_derived2v
-// CHECK-NEXT: %[[D_ADDR:.*]] = cir.alloca {{.*}} ["d", init]
+// CHECK-NEXT: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
diff --git a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
index 42b22e75067d5..afe147eda9199 100644
--- a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
+++ b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
@@ -28,8 +28,8 @@ void test() {
}
// CIR: cir.func {{.*}} @_ZN20out_of_line_operatorcviEv(%[[THIS_ARG:.+]]: !cir.ptr<!rec_out_of_line_operator>{{.*}}) -> (!s32i{{.*}})
-// CIR: %[[THIS_ALLOCA:.+]] = cir.alloca !cir.ptr<!rec_out_of_line_operator>, !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>, ["this", init]
-// CIR: %[[RETVAL:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_out_of_line_operator> -> !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]] : !cir.ptr<!rec_out_of_line_operator>, !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>
// CIR: %[[THIS_LOAD:.+]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>, !cir.ptr<!rec_out_of_line_operator>
// CIR: %[[CONST_123:.+]] = cir.const #cir.int<123> : !s32i
@@ -39,8 +39,8 @@ void test() {
// CIR: }
// CIR: cir.func no_inline comdat linkonce_odr @_ZNK15inline_operatorcviEv(%[[INLINE_THIS_ARG:.+]]: !cir.ptr<!rec_inline_operator>{{.*}}) -> (!s32i{{.*}})
-// CIR: %[[INLINE_THIS_ALLOCA:.+]] = cir.alloca !cir.ptr<!rec_inline_operator>, !cir.ptr<!cir.ptr<!rec_inline_operator>>, ["this", init]
-// CIR: %[[INLINE_RETVAL:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[INLINE_THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_inline_operator> -> !cir.ptr<!cir.ptr<!rec_inline_operator>>
+// CIR: %[[INLINE_RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[INLINE_THIS_ARG]], %[[INLINE_THIS_ALLOCA]] : !cir.ptr<!rec_inline_operator>, !cir.ptr<!cir.ptr<!rec_inline_operator>>
// CIR: %[[INLINE_THIS_LOAD:.+]] = cir.load %[[INLINE_THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_inline_operator>>, !cir.ptr<!rec_inline_operator>
// CIR: %[[CONST_987:.+]] = cir.const #cir.int<987> : !s32i
@@ -50,9 +50,9 @@ void test() {
// CIR: }
// CIR: cir.func {{.*}} @_Z4testv()
-// CIR: %[[X_ALLOCA:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[I_ALLOCA:.+]] = cir.alloca {{.*}}, {{.*}}, ["i"]
-// CIR: %[[O_ALLOCA:.+]] = cir.alloca {{.*}}, {{.*}}, ["o"]
+// CIR: %[[X_ALLOCA:.+]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[I_ALLOCA:.+]] = cir.alloca "i" {{.*}} {{.*}} -> {{.*}}
+// CIR: %[[O_ALLOCA:.+]] = cir.alloca "o" {{.*}} {{.*}} -> {{.*}}
// CIR: %[[CONST_42:.+]] = cir.const #cir.int<42> : !s32i
// CIR: cir.store align(4) %[[CONST_42]], %[[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[INLINE_CALL:.+]] = cir.call @_ZNK15inline_operatorcviEv(%[[I_ALLOCA]]) : ({{.*}}) -> (!s32i{{.*}})
diff --git a/clang/test/CIR/CodeGen/cxx-default-init.cpp b/clang/test/CIR/CodeGen/cxx-default-init.cpp
index 114bf47f3223b..5d96ef8be84c9 100644
--- a/clang/test/CIR/CodeGen/cxx-default-init.cpp
+++ b/clang/test/CIR/CodeGen/cxx-default-init.cpp
@@ -20,7 +20,7 @@ struct ZeroInit {
};
// CIR: cir.func{{.*}} @_ZN8ZeroInitC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_ZeroInit> {{.*}})
-// CIR: %[[ITER:.*]] = cir.alloca {{.*}} ["arrayinit.temp"]
+// CIR: %[[ITER:.*]] = cir.alloca "arrayinit.temp" {{.*}}
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA:.*]]
// CIR: %[[I:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -126,7 +126,7 @@ struct ValueInit {
};
// CIR: cir.func{{.*}} @_ZN9ValueInitC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_ValueInit> {{.*}})
-// CIR: %[[ITER:.*]] = cir.alloca {{.*}} ["arrayinit.temp"]
+// CIR: %[[ITER:.*]] = cir.alloca "arrayinit.temp" {{.*}}
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA:.*]]
// CIR: %[[I:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
diff --git a/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp b/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp
index f8eece43a0509..59bbbdd65d1a7 100644
--- a/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp
+++ b/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp
@@ -15,9 +15,9 @@ void cxx_rewritten_binary_operator_scalar_expr() {
bool neq = a != b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_HasOpEq, !cir.ptr<!rec_HasOpEq>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !rec_HasOpEq, !cir.ptr<!rec_HasOpEq>, ["b"]
-// CIR: %[[NEQ_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["neq", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_HasOpEq -> !cir.ptr<!rec_HasOpEq>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !rec_HasOpEq -> !cir.ptr<!rec_HasOpEq>
+// CIR: %[[NEQ_ADDR:.*]] = cir.alloca "neq" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[EQ:.*]] = cir.call @_ZNK7HasOpEqeqERKS_(%[[A_ADDR]], %[[B_ADDR]]) : (!cir.ptr<!rec_HasOpEq> {{.*}}, !cir.ptr<!rec_HasOpEq> {{.*}}) -> (!cir.bool{{.*}})
// CIR: %[[NEQ:.*]] = cir.not %[[EQ]] : !cir.bool
// CIR: cir.store{{.*}} %[[NEQ]], %[[NEQ_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
diff --git a/clang/test/CIR/CodeGen/cxx-traits.cpp b/clang/test/CIR/CodeGen/cxx-traits.cpp
index 953e79b07ab3e..90ec7806306fe 100644
--- a/clang/test/CIR/CodeGen/cxx-traits.cpp
+++ b/clang/test/CIR/CodeGen/cxx-traits.cpp
@@ -9,7 +9,7 @@ void expression_trait_expr() {
bool a = __is_lvalue_expr(0);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[CONST_FALSE:.*]] = cir.const #false
// CIR: cir.store {{.*}} %[[CONST_FALSE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -27,10 +27,10 @@ void type_trait_expr() {
bool d = __is_array(int);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["c", init]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["d", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.store {{.*}} %[[CONST_TRUE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CONST_FALSE:.*]] = cir.const #false
@@ -63,8 +63,8 @@ void array_type_trait_expr() {
unsigned long b = __array_extent(int[10][20], 1);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !u64i
// CIR: cir.store {{.*}} %[[CONST_2]], %[[A_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_20:.*]] = cir.const #cir.int<20> : !u64i
diff --git a/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp b/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp
index e654bbd02b72d..f4e34117add34 100644
--- a/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp
+++ b/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp
@@ -34,7 +34,7 @@ int call_with_member(Adder a) {
// CIR-LABEL: cir.func{{.*}} @_ZNH5AdderclERKS_i(%arg0: !cir.ptr<!rec_Adder>
// CIR-SAME: %arg1: !s32i
-// CIR: %[[SELF_SLOT:.+]] = cir.alloca !cir.ptr<!rec_Adder>, {{.*}}["self"
+// CIR: %[[SELF_SLOT:.+]] = cir.alloca "self" {{.*}} !cir.ptr<!rec_Adder>
// CIR: %[[SELF_PTR:.+]] = cir.load{{.*}} %[[SELF_SLOT]] : !cir.ptr<!cir.ptr<!rec_Adder>>, !cir.ptr<!rec_Adder>
// CIR: %[[BASE_PTR:.+]] = cir.get_member %[[SELF_PTR]][0] {name = "base"} : !cir.ptr<!rec_Adder> -> !cir.ptr<!s32i>
// CIR: %[[BASE:.+]] = cir.load{{.*}} %[[BASE_PTR]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/defaultarg.cpp b/clang/test/CIR/CodeGen/defaultarg.cpp
index b6665535c01ee..7c43fd43e6d37 100644
--- a/clang/test/CIR/CodeGen/defaultarg.cpp
+++ b/clang/test/CIR/CodeGen/defaultarg.cpp
@@ -12,7 +12,7 @@ void foo() {
}
// CIR: cir.func {{.*}} @_Z3foov()
-// CIR: %[[TMP0:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp0"]
+// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP1:.*]] = cir.const #cir.int<42>
// CIR: cir.store{{.*}} %[[TMP1]], %[[TMP0]]
// CIR: cir.call @_Z3barRKi(%[[TMP0]])
@@ -37,7 +37,7 @@ void test_ctor_defaultarg() {
}
// CIR: cir.func {{.*}} @_Z20test_ctor_defaultargv()
-// CIR: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: cir.call @_ZN1SC1Ei(%[[S]], %[[TWO]]) : (!cir.ptr<!rec_S> {{.*}}, !s32i {{.*}}) -> ()
diff --git a/clang/test/CIR/CodeGen/deferred-fn-defs.cpp b/clang/test/CIR/CodeGen/deferred-fn-defs.cpp
index e7088ba35eca7..90570e0e18436 100644
--- a/clang/test/CIR/CodeGen/deferred-fn-defs.cpp
+++ b/clang/test/CIR/CodeGen/deferred-fn-defs.cpp
@@ -31,7 +31,7 @@ void use() {
// CIR: cir.store %[[ONE]], %[[RET_ADDR:.*]]
// CIR: cir.func{{.*}} @_ZN1S12inlineCalledEv
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["this", init]
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[THREE:.*]] = cir.const #cir.int<3>
// CIR: cir.store %[[THREE]], %[[RET_ADDR:.*]]
diff --git a/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp b/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp
index d6c35272eb9f0..77b14adeab7e9 100644
--- a/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp
+++ b/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp
@@ -26,7 +26,7 @@ HasDtor::HasDtor(int) {}
void force_default_ctor() { HasDtor x; }
// CIR: cir.func {{.*}} @_ZN7HasDtorC1Ev(%[[ARG0:.*]]: !cir.ptr<!rec_HasDtor>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>, ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasDtor> -> !cir.ptr<!cir.ptr<!rec_HasDtor>>
// CIR: cir.store %[[ARG0]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/CodeGen/delegating-ctor.cpp b/clang/test/CIR/CodeGen/delegating-ctor.cpp
index 7c2f5be118c35..ed9cc0358668c 100644
--- a/clang/test/CIR/CodeGen/delegating-ctor.cpp
+++ b/clang/test/CIR/CodeGen/delegating-ctor.cpp
@@ -15,7 +15,7 @@ struct Delegating {
Delegating::Delegating() : Delegating(0) {}
// CIR: cir.func {{.*}} @_ZN10DelegatingC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Delegating> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Delegating>, !cir.ptr<!cir.ptr<!rec_Delegating>>, ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Delegating> -> !cir.ptr<!cir.ptr<!rec_Delegating>>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -45,8 +45,8 @@ struct DelegatingWithZeroing {
DelegatingWithZeroing::DelegatingWithZeroing(int) : DelegatingWithZeroing() {}
// CIR: cir.func {{.*}} @_ZN21DelegatingWithZeroingC2Ei(%[[THIS_ARG:.*]]: !cir.ptr<!rec_DelegatingWithZeroing> {{.*}}, %[[I_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_DelegatingWithZeroing>, !cir.ptr<!cir.ptr<!rec_DelegatingWithZeroing>>, ["this", init]
-// CIR: %[[I_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_DelegatingWithZeroing> -> !cir.ptr<!cir.ptr<!rec_DelegatingWithZeroing>>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store{{.*}} %[[I_ARG]], %[[I_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -107,9 +107,9 @@ Derived::Derived(const void *inVoid) { squawk(); }
// CIR-SAME: %[[THIS_ARG:.*]]: !cir.ptr<!rec_Derived>
// CIR-SAME: %[[VTT_ARG:.*]]: !cir.ptr<!cir.ptr<!void>>
// CIR-SAME: %[[INVOID_ARG:.*]]: !cir.ptr<!void>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR: %[[VTT_ADDR:.*]] = cir.alloca {{.*}} ["vtt", init]
-// CIR: %[[INVOID_ADDR:.*]] = cir.alloca {{.*}} ["inVoid", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR: %[[VTT_ADDR:.*]] = cir.alloca "vtt" {{.*}} init
+// CIR: %[[INVOID_ADDR:.*]] = cir.alloca "inVoid" {{.*}} init
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store %[[VTT_ARG]], %[[VTT_ADDR]]
// CIR: cir.store %[[INVOID_ARG]], %[[INVOID_ADDR]]
@@ -191,8 +191,8 @@ Derived::Derived(const void *inVoid) { squawk(); }
// OGCG: ret void
// CIR: cir.func {{.*}} @_ZN7DerivedC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}}, %[[VTT_ARG:.*]]: !cir.ptr<!cir.ptr<!void>> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR: %[[VTT_ADDR:.*]] = cir.alloca {{.*}} ["vtt", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR: %[[VTT_ADDR:.*]] = cir.alloca "vtt" {{.*}} init
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store %[[VTT_ARG]], %[[VTT_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -216,7 +216,7 @@ Derived::Derived(const void *inVoid) { squawk(); }
// See above for the OGCG _ZN7DerivedC2Ev constructor.
// CIR: cir.func {{.*}} @_ZN4BaseC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Base> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[VTT_ADDR_POINT:.*]] = cir.vtable.address_point(@_ZTV4Base, address_point = <index = 0, offset = 2>) : !cir.vptr
@@ -252,8 +252,8 @@ Derived::Derived(const void *inVoid) { squawk(); }
// OGCG: ret void
// CIR: cir.func {{.*}} @_ZN7DerivedC1EPKv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}}, %[[INVOID_ARG:.*]]: !cir.ptr<!void> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR: %[[INVOID_ADDR:.*]] = cir.alloca {{.*}} ["inVoid", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR: %[[INVOID_ADDR:.*]] = cir.alloca "inVoid" {{.*}} init
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store %[[INVOID_ARG]], %[[INVOID_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -303,7 +303,7 @@ Derived::Derived(const void *inVoid) { squawk(); }
// OGCG: ret void
// CIR: cir.func {{.*}} @_ZN7DerivedC1Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[NULLPTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp b/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
index bcb572f7d932e..1d85fd6ad01ab 100644
--- a/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
+++ b/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
@@ -58,7 +58,7 @@ void test_delete_array_throwing_dtor(ThrowingDtor *ptr) {
// CIR: %[[END:.*]] = cir.ptr_stride %[[PTR]], %[[NUM_ELEM]]
// CIR: %[[NOT_EMPTY:.*]] = cir.cmp ne %[[END]], %[[PTR]]
// CIR: cir.if %[[NOT_EMPTY]] {
-// CIR: %[[ARR_IDX:.*]] = cir.alloca {{.*}} ["__array_idx"]
+// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" {{.*}}
// CIR: cir.store %[[END]], %[[ARR_IDX]]
//
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp b/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp
index 2bb8d3aafe87e..512edce5f0b83 100644
--- a/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp
+++ b/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp
@@ -44,7 +44,7 @@ void test(Dtor *ptr) {
// CIR: cir.if %[[NOT_EMPTY]] {
//
// Destruct elements in reverse order.
-// CIR: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_Dtor>, !cir.ptr<!cir.ptr<!rec_Dtor>>, ["__array_idx"]
+// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_Dtor> -> !cir.ptr<!cir.ptr<!rec_Dtor>>
// CIR: cir.store %[[END]], %[[ARR_IDX]]
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[ARR_IDX]]
diff --git a/clang/test/CIR/CodeGen/delete-array.cpp b/clang/test/CIR/CodeGen/delete-array.cpp
index 6ba6f8af17bfd..71d8efe5394d5 100644
--- a/clang/test/CIR/CodeGen/delete-array.cpp
+++ b/clang/test/CIR/CodeGen/delete-array.cpp
@@ -207,7 +207,7 @@ void test_delete_array_destructed(Destructed *ptr) {
// CIR: %[[END:.*]] = cir.ptr_stride %[[PTR]], %[[NUM_ELEM]] : (!cir.ptr<!rec_Destructed>, !u64i) -> !cir.ptr<!rec_Destructed>
// CIR: %[[NOT_EMPTY:.*]] = cir.cmp ne %[[END]], %[[PTR]] : !cir.ptr<!rec_Destructed>
// CIR: cir.if %[[NOT_EMPTY]] {
-// CIR: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_Destructed>, !cir.ptr<!cir.ptr<!rec_Destructed>>, ["__array_idx"] {alignment = 1 : i64}
+// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_Destructed> -> !cir.ptr<!cir.ptr<!rec_Destructed>>
// CIR: cir.store %[[END]], %[[ARR_IDX]] : !cir.ptr<!rec_Destructed>, !cir.ptr<!cir.ptr<!rec_Destructed>>
// CIR: cir.do {
// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_Destructed>>, !cir.ptr<!rec_Destructed>
diff --git a/clang/test/CIR/CodeGen/delete-destroying.cpp b/clang/test/CIR/CodeGen/delete-destroying.cpp
index 368ea9cf3f5ad..15213902c812e 100644
--- a/clang/test/CIR/CodeGen/delete-destroying.cpp
+++ b/clang/test/CIR/CodeGen/delete-destroying.cpp
@@ -37,8 +37,8 @@ void test_destroying_delete(S *s) {
// responsible for destroying the object itself.
// CIR: cir.func {{.*}} @_Z22test_destroying_deleteP1S(%[[ARG:.*]]: !cir.ptr<!rec_S> {{.*}})
-// CIR: %[[S_ADDR:.*]] = cir.alloca !cir.ptr<!rec_S>, {{.*}} ["s", init]
-// CIR: %[[TAG_ADDR:.*]] = cir.alloca !rec_std3A3Adestroying_delete_t, {{.*}} ["destroying.delete.tag"]
+// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S>
+// CIR: %[[TAG_ADDR:.*]] = cir.alloca "destroying.delete.tag" {{.*}} !rec_std3A3Adestroying_delete_t
// CIR: cir.store %[[ARG]], %[[S_ADDR]]
// CIR: %[[S:.*]] = cir.load{{.*}} %[[S_ADDR]]
// CIR: %[[NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_S>
@@ -96,7 +96,7 @@ void test_virtual_destroying_delete(V *v) {
}
// CIR: cir.func {{.*}} @_Z30test_virtual_destroying_deleteP1V(%[[ARG:.*]]: !cir.ptr<!rec_V> {{.*}})
-// CIR: %[[V_ADDR:.*]] = cir.alloca !cir.ptr<!rec_V>, {{.*}} ["v", init]
+// CIR: %[[V_ADDR:.*]] = cir.alloca "v" {{.*}} init !cir.ptr<!rec_V>
// CIR: cir.store %[[ARG]], %[[V_ADDR]]
// CIR: %[[V:.*]] = cir.load{{.*}} %[[V_ADDR]]
// CIR: %[[NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_V>
diff --git a/clang/test/CIR/CodeGen/delete.cpp b/clang/test/CIR/CodeGen/delete.cpp
index 2fb0a936cf305..28482152b8c0d 100644
--- a/clang/test/CIR/CodeGen/delete.cpp
+++ b/clang/test/CIR/CodeGen/delete.cpp
@@ -142,7 +142,7 @@ void destroy(StructWithVirtualDestructor *x) {
}
// CIR: cir.func {{.*}} @_Z7destroyP27StructWithVirtualDestructor(%[[X_ARG:.*]]: !cir.ptr<!rec_StructWithVirtualDestructor> {{.*}})
-// CIR: %[[X_ADDR:.*]] = cir.alloca !cir.ptr<!rec_StructWithVirtualDestructor>
+// CIR: %[[X_ADDR:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_StructWithVirtualDestructor>
// CIR: cir.store %[[X_ARG]], %[[X_ADDR]]
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_StructWithVirtualDestructor>
diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp
index a5b9cb7313e00..12c60a541a5d9 100644
--- a/clang/test/CIR/CodeGen/derived-to-base.cpp
+++ b/clang/test/CIR/CodeGen/derived-to-base.cpp
@@ -26,7 +26,7 @@ void f() {
}
// CIR: cir.func {{.*}} @_Z1fv()
-// CIR: %[[D:.*]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["d", init]
+// CIR: %[[D:.*]] = cir.alloca "d" {{.*}} init !rec_Derived -> !cir.ptr<!rec_Derived>
// CIR: cir.call @_ZN7DerivedC1Ev(%[[D]]) : (!cir.ptr<!rec_Derived> {{.*}}) -> ()
// CIR: %[[D_BASE:.*]] = cir.base_class_addr %[[D]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: cir.call @_ZN4Base1fEv(%[[D_BASE]]) : (!cir.ptr<!rec_Base> {{.*}}) -> ()
@@ -48,7 +48,7 @@ void callBaseUsingDerived(Derived *derived) {
// CIR: cir.func {{.*}} @_Z20callBaseUsingDerivedP7Derived(%[[DERIVED_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}})
-// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["derived", init]
+// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca "derived" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[DERIVED_ARG]], %[[DERIVED_ADDR]]
// CIR: %[[DERIVED:.*]] = cir.load{{.*}} %[[DERIVED_ADDR]]
// CIR: %[[DERIVED_BASE:.*]] = cir.base_class_addr %[[DERIVED]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
@@ -71,8 +71,8 @@ Base *returnBaseFromDerived(Derived* derived) {
}
// CIR: cir.func {{.*}} @_Z21returnBaseFromDerivedP7Derived(%[[DERIVED_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}}) -> (!cir.ptr<!rec_Base>{{.*}})
-// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["derived", init]
-// CIR: %[[BASE_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["__retval"]
+// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca "derived" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[BASE_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_Base> -> !cir.ptr<!cir.ptr<!rec_Base>>
// CIR: cir.store %[[DERIVED_ARG]], %[[DERIVED_ADDR]]
// CIR: %[[DERIVED:.*]] = cir.load{{.*}} %[[DERIVED_ADDR]]
// CIR: %[[DERIVED_BASE:.*]] = cir.base_class_addr %[[DERIVED]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
diff --git a/clang/test/CIR/CodeGen/destructors.cpp b/clang/test/CIR/CodeGen/destructors.cpp
index c63b8d6048722..726290fe24910 100644
--- a/clang/test/CIR/CodeGen/destructors.cpp
+++ b/clang/test/CIR/CodeGen/destructors.cpp
@@ -62,8 +62,8 @@ void test_array_destructor() {
}
// CIR: cir.func {{.*}} @_Z21test_array_destructorv()
-// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_array_element x 5>, !cir.ptr<!cir.array<!rec_array_element x 5>>, ["arr", init]
-// CIR: %[[ARR_PTR:.*]] = cir.alloca !cir.ptr<!rec_array_element>, !cir.ptr<!cir.ptr<!rec_array_element>>, ["arrayinit.temp", init]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_array_element x 5> -> !cir.ptr<!cir.array<!rec_array_element x 5>>
+// CIR: %[[ARR_PTR:.*]] = cir.alloca "arrayinit.temp" {{.*}} init !cir.ptr<!rec_array_element> -> !cir.ptr<!cir.ptr<!rec_array_element>>
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!rec_array_element x 5>>
// CIR: cir.store{{.*}} %[[BEGIN]], %[[ARR_PTR]]
// CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !s64i
@@ -85,7 +85,7 @@ void test_array_destructor() {
// CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!rec_array_element x 5>>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[FIVE]] : (!cir.ptr<!rec_array_element>, !u64i)
-// CIR: %[[ARR_PTR:.*]] = cir.alloca !cir.ptr<!rec_array_element>, !cir.ptr<!cir.ptr<!rec_array_element>>, ["__array_idx"]
+// CIR: %[[ARR_PTR:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_array_element> -> !cir.ptr<!cir.ptr<!rec_array_element>>
// CIR: cir.store %[[END]], %[[ARR_PTR]]
// CIR: cir.do {
// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]]
diff --git a/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp b/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp
index cb920e875d78e..90135ec35173e 100644
--- a/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp
+++ b/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp
@@ -19,11 +19,11 @@ B::~B() {
}
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK: %[[B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["b"]
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} !rec_B -> !cir.ptr<!rec_B>
// CHECK: cir.call @_ZN1BD1Ev(%[[B]]) nothrow : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CHECK: cir.func{{.*}} @_ZN1BD2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["this", init]
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
diff --git a/clang/test/CIR/CodeGen/dtor-alias.cpp b/clang/test/CIR/CodeGen/dtor-alias.cpp
index a615d07afe1b3..b4bf60650b818 100644
--- a/clang/test/CIR/CodeGen/dtor-alias.cpp
+++ b/clang/test/CIR/CodeGen/dtor-alias.cpp
@@ -16,7 +16,7 @@ B::~B() {
// OGCG: @_ZN1BD1Ev = unnamed_addr alias void (ptr), ptr @_ZN1BD2Ev
// CHECK: cir.func{{.*}} @_ZN1BD2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["this", init]
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
@@ -42,7 +42,7 @@ void baz() {
}
// CHECK: cir.func{{.*}} @_ZN5StrukD2Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>, ["this", init]
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK: cir.return
@@ -50,7 +50,7 @@ void baz() {
// CHECK-NOT: cir.func{{.*}} @_ZN5StrukD1Ev
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK: %[[S_ADDR:.*]] = cir.alloca !rec_Struk, !cir.ptr<!rec_Struk>, ["s"]
+// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD2Ev(%[[S_ADDR]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// LLVM: define linkonce_odr void @_ZN5StrukD2Ev(ptr{{.*}} %[[THIS_ARG]])
diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp
index 4c1a98e1ce9da..0a6426fd3908d 100644
--- a/clang/test/CIR/CodeGen/dtors.cpp
+++ b/clang/test/CIR/CodeGen/dtors.cpp
@@ -14,7 +14,7 @@ void test_temporary_dtor() {
}
// CIR: cir.func {{.*}} @_Z19test_temporary_dtorv()
-// CIR: %[[ALLOCA:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["agg.tmp.ensured"]
+// CIR: %[[ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_A -> !cir.ptr<!rec_A>
// CIR: cir.call @_ZN1AD1Ev(%[[ALLOCA]]) nothrow : (!cir.ptr<!rec_A> {{.*}}) -> ()
// LLVM: define dso_local void @_Z19test_temporary_dtorv(){{.*}}
@@ -35,8 +35,8 @@ bool make_temp(const B &) { return false; }
bool test_temp_or() { return make_temp(1) || make_temp(2); }
// CIR: cir.func{{.*}} @_Z12test_temp_orv()
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"]
-// CIR: %[[REF_TMP0:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp0"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_B -> !cir.ptr<!rec_B>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP0]], %[[ONE]])
// CIR: cir.cleanup.scope {
@@ -45,8 +45,8 @@ bool test_temp_or() { return make_temp(1) || make_temp(2); }
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.yield %[[TRUE]] : !cir.bool
// CIR: }, false {
-// CIR: %[[REF_TMP1:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp1"]
-// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["tmp.exprcleanup"]
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP1]], %[[TWO]])
// CIR: cir.cleanup.scope {
@@ -137,15 +137,15 @@ bool test_temp_or() { return make_temp(1) || make_temp(2); }
bool test_temp_and() { return make_temp(1) && make_temp(2); }
// CIR: cir.func{{.*}} @_Z13test_temp_andv()
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"]
-// CIR: %[[REF_TMP0:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp0"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_B -> !cir.ptr<!rec_B>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP0]], %[[ONE]])
// CIR: cir.cleanup.scope {
// CIR: %[[MAKE_TEMP0:.*]] = cir.call @_Z9make_tempRK1B(%[[REF_TMP0]])
// CIR: %[[TERNARY:.*]] = cir.ternary(%[[MAKE_TEMP0]], true {
-// CIR: %[[REF_TMP1:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp1"]
-// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["tmp.exprcleanup"]
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP1]], %[[TWO]])
// CIR: cir.cleanup.scope {
@@ -334,13 +334,13 @@ int test_temp_in_condition(G &obj) {
}
// CIR: cir.func {{.*}} @_Z22test_temp_in_conditionR1G(%[[ARG0:.*]]: !cir.ptr<!rec_G> {{.*}}) -> (!s32i {{.*}}) {{.*}} {
-// CIR: %[[OBJ:.*]] = cir.alloca !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>, ["obj", init, const]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[OBJ:.*]] = cir.alloca "obj" {{.*}} init const !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], %[[OBJ]]
// CIR: cir.scope {
-// CIR: %[[REF_TMP0:.*]] = cir.alloca !rec_G, !cir.ptr<!rec_G>, ["ref.tmp0"]
-// CIR: %[[REF_TMP1:.*]] = cir.alloca !rec_G, !cir.ptr<!rec_G>, ["ref.tmp1"]
-// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["tmp.exprcleanup"]
+// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_G -> !cir.ptr<!rec_G>
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_G -> !cir.ptr<!rec_G>
+// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[LOAD_OBJ:.*]] = cir.load{{.*}} %[[OBJ]] : !cir.ptr<!cir.ptr<!rec_G>>, !cir.ptr<!rec_G>
// CIR: %[[COPY:.*]] = cir.call @_ZNK1G4copyEv(%[[LOAD_OBJ]]) : (!cir.ptr<!rec_G> {{.*}}) -> !rec_G
// CIR: cir.store{{.*}} %[[COPY]], %[[REF_TMP0]]
diff --git a/clang/test/CIR/CodeGen/embed-expr.c b/clang/test/CIR/CodeGen/embed-expr.c
index 4350f69d2ac97..5dbf3f19335e1 100644
--- a/clang/test/CIR/CodeGen/embed-expr.c
+++ b/clang/test/CIR/CodeGen/embed-expr.c
@@ -15,7 +15,7 @@ void embed_expr_on_scalar_with_constants() {
// CIR-DAG: cir.global "private" constant cir_private @[[EMBED_A:.*]] = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<47> : !s32i]> : !cir.array<!s32i x 3>
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[ARRAY:.*]] = cir.get_global @[[EMBED_A]] : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: cir.copy %[[ARRAY]] to %[[A_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>>
@@ -34,8 +34,8 @@ void embed_expr_on_scalar_with_non_constants() {
};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[B_PTR:.*]] = cir.cast array_to_ptrdecay %[[B_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store {{.*}} %[[TMP_A]], %[[B_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/empty-union.c b/clang/test/CIR/CodeGen/empty-union.c
index dae5193adb546..f1e9534b9ab83 100644
--- a/clang/test/CIR/CodeGen/empty-union.c
+++ b/clang/test/CIR/CodeGen/empty-union.c
@@ -18,7 +18,7 @@ void useEmpty() {
union Empty e;
}
// CIR: cir.func {{.*}}@useEmpty()
-// CIR: cir.alloca !rec_Empty, !cir.ptr<!rec_Empty>, ["e"] {alignment = 1 : i64}
+// CIR: cir.alloca "e" align(1) !rec_Empty -> !cir.ptr<!rec_Empty>
// LLVM: define {{.*}} void @useEmpty()
// LLVM: alloca %union.Empty, i64 1, align 1
// OGCG: define {{.*}} void @useEmpty()
@@ -28,7 +28,7 @@ void useEmptyAligned() {
union EmptyAligned e;
}
// CIR: cir.func {{.*}}@useEmptyAligned()
-// CIR: cir.alloca !rec_EmptyAligned, !cir.ptr<!rec_EmptyAligned>, ["e"] {alignment = 16 : i64}
+// CIR: cir.alloca "e" align(16) !rec_EmptyAligned -> !cir.ptr<!rec_EmptyAligned>
// LLVM: define {{.*}} void @useEmptyAligned()
// LLVM: alloca %union.EmptyAligned, i64 1, align 16
// OGCG: define {{.*}} void @useEmptyAligned()
diff --git a/clang/test/CIR/CodeGen/empty-union.cpp b/clang/test/CIR/CodeGen/empty-union.cpp
index 5a3595a669d6e..2feae0b77cbb9 100644
--- a/clang/test/CIR/CodeGen/empty-union.cpp
+++ b/clang/test/CIR/CodeGen/empty-union.cpp
@@ -40,7 +40,7 @@ void useEmpty() {
Empty e;
}
// CIR: cir.func {{.*}}@_Z8useEmptyv()
-// CIR: cir.alloca !rec_Empty, !cir.ptr<!rec_Empty>, ["e"] {alignment = 1 : i64}
+// CIR: cir.alloca "e" align(1) !rec_Empty -> !cir.ptr<!rec_Empty>
// LLVM: define {{.*}} void @_Z8useEmptyv()
// LLVM: alloca %union.Empty, i64 1, align 1
// OGCG: define {{.*}} void @_Z8useEmptyv()
@@ -50,7 +50,7 @@ void useEmptyAligned() {
EmptyAligned e;
}
// CIR: cir.func {{.*}}@_Z15useEmptyAlignedv()
-// CIR: cir.alloca !rec_EmptyAligned, !cir.ptr<!rec_EmptyAligned>, ["e"] {alignment = 16 : i64}
+// CIR: cir.alloca "e" align(16) !rec_EmptyAligned -> !cir.ptr<!rec_EmptyAligned>
// LLVM: define {{.*}} void @_Z15useEmptyAlignedv()
// LLVM: alloca %union.EmptyAligned, i64 1, align 16
// OGCG: define {{.*}} void @_Z15useEmptyAlignedv()
diff --git a/clang/test/CIR/CodeGen/fixed-point-literal.c b/clang/test/CIR/CodeGen/fixed-point-literal.c
index 4c2fa18a04592..e61622ef720a7 100644
--- a/clang/test/CIR/CodeGen/fixed-point-literal.c
+++ b/clang/test/CIR/CodeGen/fixed-point-literal.c
@@ -128,11 +128,11 @@ void test_sat_short_accum() {
// LLVM: void @test_sat_short_accum
// OGCG: void @test_sat_short_accum
_Sat short _Accum ssa;
- // CIR: cir.alloca !s16i, !cir.ptr<!s16i>, ["ssa"]
+ // CIR: cir.alloca "ssa" {{.*}} !s16i -> !cir.ptr<!s16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
_Sat unsigned short _Accum susa;
- // CIR: cir.alloca !u16i, !cir.ptr<!u16i>, ["susa"]
+ // CIR: cir.alloca "susa" {{.*}} !u16i -> !cir.ptr<!u16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
}
@@ -142,11 +142,11 @@ void test_sat_accum() {
// LLVM: void @test_sat_accum
// OGCG: void @test_sat_accum
_Sat _Accum sa;
- // CIR: cir.alloca !s32i, !cir.ptr<!s32i>, ["sa"]
+ // CIR: cir.alloca "sa" {{.*}} !s32i -> !cir.ptr<!s32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
_Sat unsigned _Accum sua;
- // CIR: cir.alloca !u32i, !cir.ptr<!u32i>, ["sua"]
+ // CIR: cir.alloca "sua" {{.*}} !u32i -> !cir.ptr<!u32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
}
@@ -156,11 +156,11 @@ void test_sat_long_accum() {
// LLVM: void @test_sat_long_accum
// OGCG: void @test_sat_long_accum
_Sat long _Accum sla;
- // CIR: cir.alloca !s64i, !cir.ptr<!s64i>, ["sla"]
+ // CIR: cir.alloca "sla" {{.*}} !s64i -> !cir.ptr<!s64i>
// LLVM: alloca i64, i64 1, align 8
// OGCG: alloca i64, align 8
_Sat unsigned long _Accum sula;
- // CIR: cir.alloca !u64i, !cir.ptr<!u64i>, ["sula"]
+ // CIR: cir.alloca "sula" {{.*}} !u64i -> !cir.ptr<!u64i>
// LLVM: alloca i64, i64 1, align 8
// OGCG: alloca i64, align 8
}
@@ -170,11 +170,11 @@ void test_sat_short_fract() {
// LLVM: void @test_sat_short_fract
// OGCG: void @test_sat_short_fract
_Sat short _Fract ssf;
- // CIR: cir.alloca !s8i, !cir.ptr<!s8i>, ["ssf"]
+ // CIR: cir.alloca "ssf" {{.*}} !s8i -> !cir.ptr<!s8i>
// LLVM: alloca i8, i64 1, align 1
// OGCG: alloca i8, align 1
_Sat unsigned short _Fract susf;
- // CIR: cir.alloca !u8i, !cir.ptr<!u8i>, ["susf"]
+ // CIR: cir.alloca "susf" {{.*}} !u8i -> !cir.ptr<!u8i>
// LLVM: alloca i8, i64 1, align 1
// OGCG: alloca i8, align 1
}
@@ -184,11 +184,11 @@ void test_sat_fract() {
// LLVM: void @test_sat_fract
// OGCG: void @test_sat_fract
_Sat _Fract sf;
- // CIR: cir.alloca !s16i, !cir.ptr<!s16i>, ["sf"]
+ // CIR: cir.alloca "sf" {{.*}} !s16i -> !cir.ptr<!s16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
_Sat unsigned _Fract suf;
- // CIR: cir.alloca !u16i, !cir.ptr<!u16i>, ["suf"]
+ // CIR: cir.alloca "suf" {{.*}} !u16i -> !cir.ptr<!u16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
}
@@ -198,11 +198,11 @@ void test_sat_long_fract() {
// LLVM: void @test_sat_long_fract
// OGCG: void @test_sat_long_fract
_Sat long _Fract slf;
- // CIR: cir.alloca !s32i, !cir.ptr<!s32i>, ["slf"]
+ // CIR: cir.alloca "slf" {{.*}} !s32i -> !cir.ptr<!s32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
_Sat unsigned long _Fract sulf;
- // CIR: cir.alloca !u32i, !cir.ptr<!u32i>, ["sulf"]
+ // CIR: cir.alloca "sulf" {{.*}} !u32i -> !cir.ptr<!u32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
}
diff --git a/clang/test/CIR/CodeGen/forrange.cpp b/clang/test/CIR/CodeGen/forrange.cpp
index f31c2fe0e37b5..cb32fb1dd6bf4 100644
--- a/clang/test/CIR/CodeGen/forrange.cpp
+++ b/clang/test/CIR/CodeGen/forrange.cpp
@@ -17,12 +17,12 @@ void for_range() {
// CIR: cir.func{{.*}} @_Z3endR9Container(!cir.ptr<!rec_Container>{{.*}}) -> (!cir.ptr<!rec_Element{{.*}})
// CIR: cir.func{{.*}} @_Z9for_rangev()
-// CIR: %[[C_ADDR:.*]] = cir.alloca !rec_Container{{.*}} ["c"]
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_Container
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Container>{{.*}} ["__range1", init, const]
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["__begin1", init]
-// CIR: %[[END_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["__end1", init]
-// CIR: %[[E_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["e", init, const]
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_Container>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !cir.ptr<!rec_Element>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !cir.ptr<!rec_Element>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: %[[C_REF:.*]] = cir.load{{.*}} %[[RANGE_ADDR]]
// CIR: %[[BEGIN:.*]] = cir.call @_Z5beginR9Container(%[[C_REF]])
@@ -60,12 +60,12 @@ void for_range2() {
}
// CIR: cir.func{{.*}} @_Z10for_range2v()
-// CIR: %[[C_ADDR:.*]] = cir.alloca !rec_C2{{.*}} ["c"]
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C2
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C2>{{.*}} ["__range1", init, const]
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["__begin1", init]
-// CIR: %[[END_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["__end1", init]
-// CIR: %[[E_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["e", init, const]
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C2>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !cir.ptr<!rec_Element>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !cir.ptr<!rec_Element>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: %[[C_REF:.*]] = cir.load{{.*}} %[[RANGE_ADDR]]
// CIR: %[[BEGIN:.*]] = cir.call @_ZN2C25beginEv(%[[C_REF]])
@@ -112,12 +112,12 @@ void for_range3() {
}
// CIR: cir.func{{.*}} @_Z10for_range3v()
-// CIR: %[[C_ADDR:.*]] = cir.alloca !rec_C3{{.*}} ["c"]
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C3
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C3>{{.*}} ["__range1", init, const]
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca !rec_Iterator, !cir.ptr<!rec_Iterator>{{.*}} ["__begin1", init]
-// CIR: %[[END_ADDR:.*]] = cir.alloca !rec_Iterator, !cir.ptr<!rec_Iterator>{{.*}} ["__end1", init]
-// CIR: %[[E_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["e", init, const]
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C3>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: cir.for : cond {
// CIR: %[[ITER_NE:.*]] = cir.call @_ZNK8IteratorneERKS_(%[[BEGIN_ADDR]], %[[END_ADDR]])
@@ -143,11 +143,11 @@ void for_range4() {
// CIR: cir.func{{.*}} @_Z10for_range4v()
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C3>{{.*}} ["__range1", init, const]
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca !rec_Iterator, !cir.ptr<!rec_Iterator>{{.*}} ["__begin1", init]
-// CIR: %[[END_ADDR:.*]] = cir.alloca !rec_Iterator, !cir.ptr<!rec_Iterator>{{.*}} ["__end1", init]
-// CIR: %[[E_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Element>{{.*}} ["e", init, const]
-// CIR: %[[HD:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["hd"]
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C3>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
+// CIR: %[[HD:.*]] = cir.alloca "hd" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: cir.for : cond {
// CIR: %[[ITER_NE:.*]] = cir.call @_ZNK8IteratorneERKS_(%[[BEGIN_ADDR]], %[[END_ADDR]])
diff --git a/clang/test/CIR/CodeGen/generic-selection.c b/clang/test/CIR/CodeGen/generic-selection.c
index c1659382a7059..e061c728e141d 100644
--- a/clang/test/CIR/CodeGen/generic-selection.c
+++ b/clang/test/CIR/CodeGen/generic-selection.c
@@ -10,8 +10,8 @@ void foo() {
int r = _Generic(a, double: 1, float: 2, int: 3, default: 4);
}
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[RES:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["r", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RES:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[RES_VAL:.*]] = cir.const #cir.int<3> : !s32i
// CIR: cir.store{{.*}} %[[RES_VAL]], %[[RES]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/global-array-dtor.cpp b/clang/test/CIR/CodeGen/global-array-dtor.cpp
index 4714fc9d4e365..2cbc8395e8168 100644
--- a/clang/test/CIR/CodeGen/global-array-dtor.cpp
+++ b/clang/test/CIR/CodeGen/global-array-dtor.cpp
@@ -30,7 +30,7 @@ ArrayDtor arrDtor[16];
// CIR: %[[CONST16:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR_ARG]] : !cir.ptr<!void> -> !cir.ptr<!rec_ArrayDtor>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST16]] : (!cir.ptr<!rec_ArrayDtor>, !u64i) -> !cir.ptr<!rec_ArrayDtor>
-// CIR: %[[CUR_ADDR:.*]] = cir.alloca !cir.ptr<!rec_ArrayDtor>, !cir.ptr<!cir.ptr<!rec_ArrayDtor>>, ["__array_idx"]
+// CIR: %[[CUR_ADDR:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_ArrayDtor> -> !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.store %[[END]], %[[CUR_ADDR]] : !cir.ptr<!rec_ArrayDtor>, !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[CUR_ADDR]] : !cir.ptr<!cir.ptr<!rec_ArrayDtor>>, !cir.ptr<!rec_ArrayDtor>
diff --git a/clang/test/CIR/CodeGen/global-init.cpp b/clang/test/CIR/CodeGen/global-init.cpp
index a9f4e75732562..e2ef9ccd11426 100644
--- a/clang/test/CIR/CodeGen/global-init.cpp
+++ b/clang/test/CIR/CodeGen/global-init.cpp
@@ -191,7 +191,7 @@ ArrayDtor arrDtor[16];
// CIR: %[[CONST16:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR_ARG]] : !cir.ptr<!void> -> !cir.ptr<!rec_ArrayDtor>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST16]] : (!cir.ptr<!rec_ArrayDtor>, !u64i) -> !cir.ptr<!rec_ArrayDtor>
-// CIR: %[[CUR_ADDR:.*]] = cir.alloca !cir.ptr<!rec_ArrayDtor>, !cir.ptr<!cir.ptr<!rec_ArrayDtor>>, ["__array_idx"]
+// CIR: %[[CUR_ADDR:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_ArrayDtor> -> !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.store %[[END]], %[[CUR_ADDR]] : !cir.ptr<!rec_ArrayDtor>, !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[CUR_ADDR]] : !cir.ptr<!cir.ptr<!rec_ArrayDtor>>, !cir.ptr<!rec_ArrayDtor>
diff --git a/clang/test/CIR/CodeGen/gnu-null.cpp b/clang/test/CIR/CodeGen/gnu-null.cpp
index d1d15f2007621..6fe3fe89e67d7 100644
--- a/clang/test/CIR/CodeGen/gnu-null.cpp
+++ b/clang/test/CIR/CodeGen/gnu-null.cpp
@@ -10,8 +10,8 @@ void gnu_null_expr() {
int *b = __null;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
// CIR: cir.store {{.*}} %[[CONST_0]], %[[A_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR: %[[CONST_NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/gnu-ptr-math.c b/clang/test/CIR/CodeGen/gnu-ptr-math.c
index e5b811a1d42fd..3067c71a6eebb 100644
--- a/clang/test/CIR/CodeGen/gnu-ptr-math.c
+++ b/clang/test/CIR/CodeGen/gnu-ptr-math.c
@@ -9,8 +9,8 @@ typedef int(*fptr)(int, double);
vptr vptr_add(vptr p) {
// CIR-LABEL: vptr_add
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -28,8 +28,8 @@ vptr vptr_add(vptr p) {
vptr vptr_sub(vptr p) {
// CIR-LABEL: vptr_sub
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-2> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -47,8 +47,8 @@ vptr vptr_sub(vptr p) {
vptr vptr_inc(vptr p) {
// CIR-LABEL: vptr_inc
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -65,8 +65,8 @@ vptr vptr_inc(vptr p) {
}
vptr vptr_dec(vptr p) {
// CIR-LABEL: vptr_dec
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -84,8 +84,8 @@ vptr vptr_dec(vptr p) {
fptr fptr_add(fptr p) {
// CIR-LABEL: fptr_add
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -103,8 +103,8 @@ fptr fptr_add(fptr p) {
fptr fptr_sub(fptr p) {
// CIR-LABEL: fptr_sub
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-2> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -122,8 +122,8 @@ fptr fptr_sub(fptr p) {
fptr fptr_inc(fptr p) {
// CIR-LABEL: fptr_inc
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -139,8 +139,8 @@ fptr fptr_inc(fptr p) {
}
fptr fptr_dec(fptr p) {
// CIR-LABEL: fptr_dec
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["p", init]
- // CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, ["__retval"]
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
diff --git a/clang/test/CIR/CodeGen/if.cpp b/clang/test/CIR/CodeGen/if.cpp
index b5e0feeccb25e..e2d75eedd24b8 100644
--- a/clang/test/CIR/CodeGen/if.cpp
+++ b/clang/test/CIR/CodeGen/if.cpp
@@ -261,9 +261,9 @@ int if_init() {
}
// CIR: cir.func{{.*}} @_Z7if_initv() -> (!s32i{{.*}})
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>,
+// CIR: %[[X:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !s32i
// CIR: cir.store{{.*}} %[[CONST42]], %[[X]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[X_VAL:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/implicit-return-zero.c b/clang/test/CIR/CodeGen/implicit-return-zero.c
index f9aeb3547823c..a2233295bbfdc 100644
--- a/clang/test/CIR/CodeGen/implicit-return-zero.c
+++ b/clang/test/CIR/CodeGen/implicit-return-zero.c
@@ -18,7 +18,7 @@ int main(void) {
}
// CIR-LABEL: cir.func{{.*}} @main
-// CIR: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[LOAD:.*]] = cir.load %[[RET]] : !cir.ptr<!s32i>, !s32i
@@ -51,7 +51,7 @@ int main(void) {
}
// CIR-LABEL: cir.func{{.*}} @main
-// CIR: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.if
diff --git a/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp b/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
index 9dc1d1e76dbd4..0c87bdaa99f52 100644
--- a/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
+++ b/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
@@ -12,7 +12,7 @@ void test(void *p) {
}
// CIR: cir.func{{.*}} @_Z4testPv
-// CIR-NEXT: %[[P:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init] {alignment = 8 : i64}
+// CIR-NEXT: %[[P:.*]] = cir.alloca "p" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: cir.store %arg0, %[[P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: %[[P1:.*]] = cir.load align(8) %[[P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR-NEXT: %[[P2:.*]] = cir.cast bitcast %[[P1]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
@@ -37,7 +37,7 @@ void test(void *p) {
void test_complex(void *p) { new (p) int _Complex(); }
// CIR: cir.func{{.*}} @_Z12test_complexPv
-// CIR: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: cir.store %[[ARG_0:.*]], %[[P_ADDR:.*]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[TMP_P:.*]] = cir.load {{.*}} %[[P_ADDR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[P_COMPLEX:.*]] = cir.cast bitcast %[[TMP_P:.*]] : !cir.ptr<!void> -> !cir.ptr<!cir.complex<!s32i>>
diff --git a/clang/test/CIR/CodeGen/inherited-ctors.cpp b/clang/test/CIR/CodeGen/inherited-ctors.cpp
index 8684b2142b68f..60c47d752e59f 100644
--- a/clang/test/CIR/CodeGen/inherited-ctors.cpp
+++ b/clang/test/CIR/CodeGen/inherited-ctors.cpp
@@ -43,8 +43,8 @@ void fallsthrough() {
//
//
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN7DerivedCI24BaseEi(%{{.*}}: !cir.ptr<!rec_Derived>{{.*}}, %{{.*}}: !s32i{{.*}}) special_member<#cir.cxx_ctor<!rec_Derived, custom>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["this", init]
-// CIR: %[[INT_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["", init]
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[INT_ALLOCA:.*]] = cir.alloca "" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS_LOAD]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[INT:.*]] = cir.load align(4) %[[INT_ALLOCA]] : !cir.ptr<!s32i>, !s32i
@@ -67,7 +67,7 @@ void fallsthrough() {
// LLVM-LABEL: declare void @_ZN4BaseC2Efz(ptr {{.*}}, float {{.*}}, ...)
//
// CIR-LABEL: cir.func no_inline dso_local @_Z26cannotEmitDelegateCallArgsv()
-// CIR: %[[TMP_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["tmp", init]
+// CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "tmp" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: %[[FP_1_1:.*]] = cir.const #cir.fp<1.1{{.*}}> : !cir.float
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: %[[THREE:.*]] = cir.const #cir.fp<3.0{{.*}}> : !cir.double
@@ -81,8 +81,8 @@ void fallsthrough() {
// LLVM: call void (ptr, float, ...) @_ZN4BaseC2Efz(ptr {{.*}}%[[TMP_LOAD]], float {{.*}}1.100000e+00, i32 {{.*}}2, double {{.*}}3.000000e+00)
//
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN11VirtDerivedCI24BaseEi(%{{.*}}: !cir.ptr<!rec_VirtDerived> {{.*}}, %{{.*}}: !cir.ptr<!cir.ptr<!void>>{{.*}}) special_member<#cir.cxx_ctor<!rec_VirtDerived, custom>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_VirtDerived>, !cir.ptr<!cir.ptr<!rec_VirtDerived>>, ["this", init] {alignment = 8 : i64}
-// CIR: %[[VTT_ALLOCA:.]] = cir.alloca !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, ["vtt", init] {alignment = 8 : i64}
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_VirtDerived> -> !cir.ptr<!cir.ptr<!rec_VirtDerived>>
+// CIR: %[[VTT_ALLOCA:.]] = cir.alloca "vtt" align(8) init !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtDerived>>, !cir.ptr<!rec_VirtDerived>
// CIR: %[[VTT:.*]] = cir.load align(8) %[[VTT_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[VTT_ADDR:.*]] = cir.vtt.address_point %[[VTT]] : !cir.ptr<!cir.ptr<!void>>, offset = 0 -> !cir.ptr<!cir.ptr<!void>>
@@ -101,8 +101,8 @@ void fallsthrough() {
//
//
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN21VirtualDelegatingCtorC1Ei(%{{.*}}: !cir.ptr<!rec_VirtualDelegatingCtor> {{.*}}, %{{.*}}: !s32i {{.*}}) special_member<#cir.cxx_ctor<!rec_VirtualDelegatingCtor, custom>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_VirtualDelegatingCtor>, !cir.ptr<!cir.ptr<!rec_VirtualDelegatingCtor>>, ["this", init] {alignment = 8 : i64}
-// CIR: %[[X_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_VirtualDelegatingCtor> -> !cir.ptr<!cir.ptr<!rec_VirtualDelegatingCtor>>
+// CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtualDelegatingCtor>>, !cir.ptr<!rec_VirtualDelegatingCtor>
// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS_LOAD]] : !cir.ptr<!rec_VirtualDelegatingCtor> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/init-list-lvalue.cpp b/clang/test/CIR/CodeGen/init-list-lvalue.cpp
index fd4df4558318b..47be623c4b29f 100644
--- a/clang/test/CIR/CodeGen/init-list-lvalue.cpp
+++ b/clang/test/CIR/CodeGen/init-list-lvalue.cpp
@@ -14,8 +14,8 @@ void test1(int i) {
// CIR: cir.func {{.*}}@_Z5test1i(%[[I_ARG:.*]]: {{.*}})
// LLVM: define {{.*}}void @_Z5test1i(i32 {{.*}}%[[I_ARG:.*]])
int &refI = {i};
- // CIR: %[[I_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
- // CIR: %[[REFI_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["refI", init, const]
+ // CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[REFI_ALLOCA:.*]] = cir.alloca "refI" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.store %[[I_ARG]], %[[I_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store {{.*}}%[[I_ALLOCA]], %[[REFI_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// LLVM: %[[I_ALLOCA:.*]] = alloca i32
@@ -29,8 +29,8 @@ void test2() {
// LLVM-LABEL: define {{.*}}void @_Z5test2v()
Struct s {1, "asdf"};
Struct &refS = {s};
- // CIR: %[[S_ALLOCA:.*]] = cir.alloca !rec_Struct, !cir.ptr<!rec_Struct>, ["s", init]
- // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>, ["refS", init, const]
+ // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" {{.*}} init !rec_Struct -> !cir.ptr<!rec_Struct>
+ // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca "refS" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: %[[GET_S_INIT:.*]] = cir.get_global @__const._Z5test2v.s : !cir.ptr<!rec_Struct>
// CIR: cir.copy %[[GET_S_INIT]] to %[[S_ALLOCA]] : !cir.ptr<!rec_Struct> loc(#loc33)
// CIR: cir.store {{.*}}%[[S_ALLOCA]], %[[REFS_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
@@ -47,8 +47,8 @@ void test3(Struct &s) {
// LLVM: define dso_local void @_Z5test3R6Struct(ptr{{.*}}%[[S_ARG:.*]])
using refSTy = Struct &;
Struct &refS = refSTy{s};
- // CIR: %[[S_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>, ["s", init, const]
- // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>, ["refS", init, const]
+ // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
+ // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca "refS" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: cir.store %[[S_ARG]], %[[S_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: %[[S_LOAD:.*]] = cir.load %[[S_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Struct>>, !cir.ptr<!rec_Struct>
// CIR: cir.store {{.*}}%[[S_LOAD]], %[[REFS_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
@@ -65,8 +65,8 @@ void test4() {
Struct s;
auto& [sb1, sb2] {s};
- // CIR: %[[S_ALLOCA:.*]] = cir.alloca !rec_Struct, !cir.ptr<!rec_Struct>, ["s"] {alignment = 8 : i64}
- // CIR: %[[SB_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>, ["", init, const]
+ // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" align(8) !rec_Struct -> !cir.ptr<!rec_Struct>
+ // CIR: %[[SB_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: cir.store {{.*}}%[[S_ALLOCA]], %[[SB_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
// LLVM: %[[S_ALLOCA:.*]] = alloca %struct.Struct
// LLVM: %[[SB_ALLOCA:.*]] = alloca ptr
diff --git a/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp b/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp
index 9cda3d610cd08..bacb207ffc842 100644
--- a/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp
+++ b/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp
@@ -16,8 +16,8 @@ void initalizer_list_with_two_pointers_layout() {
std::initializer_list<int> a = {10, 20, 30};
}
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>>, ["ref.tmp0"]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_std3A3Ainitializer_list3Cint3E, !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>, ["a", init]
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_std3A3Ainitializer_list3Cint3E -> !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>
// CIR: %[[ARR_PTR:.*]] = cir.cast array_to_ptrdecay %[[ARR_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: %[[CONST_S32_10:.*]] = cir.const #cir.int<10> : !s32i
// CIR: cir.store {{.*}} %[[CONST_S32_10]], %[[ARR_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/inline-asm.c b/clang/test/CIR/CodeGen/inline-asm.c
index 719b645310918..2ccb86adc69e3 100644
--- a/clang/test/CIR/CodeGen/inline-asm.c
+++ b/clang/test/CIR/CodeGen/inline-asm.c
@@ -38,7 +38,7 @@ void empty2() {
}
// CIR: cir.func{{.*}}@empty3
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[X]] : !cir.ptr<!s32i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -52,7 +52,7 @@ void empty3(int x) {
}
// CIR: cir.func{{.*}}@empty4
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [%[[X]] : !cir.ptr<!s32i> (maybe_memory)],
@@ -66,7 +66,7 @@ void empty4(int x) {
}
// CIR: cir.func{{.*}}@empty5
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[X]] : !cir.ptr<!s32i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -80,7 +80,7 @@ void empty5(int x) {
}
// CIR: cir.func{{.*}}@empty6
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -97,8 +97,8 @@ void empty6(int x) {
}
// CIR: cir.func{{.*}}@add1
-// CIR: %[[X:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -125,7 +125,7 @@ unsigned add1(unsigned int x) {
}
// CIR: cir.func{{.*}}@add2
-// CIR: %[[X:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -146,7 +146,7 @@ unsigned add2(unsigned int x) {
}
// CIR: cir.func{{.*}}@add3
-// CIR: %[[X:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CIR: %[[X_LOAD:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -169,7 +169,7 @@ unsigned add3(unsigned int x) { // ((42 + x) - 1) * 2
}
// CIR: cir.func{{.*}}@add4
-// CIR: %[[X:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[X_LOAD:.*]] = cir.load {{.*}} %[[X]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR-NEXT: cir.asm(x86_att,
// CIR-NEXT: out = [%[[X_LOAD]] : !cir.ptr<!s32i> (maybe_memory)],
@@ -186,9 +186,9 @@ void add4(int *x) {
}
// CIR: cir.func{{.*}}@add5
-// CIR: %[[X:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["x", init]
-// CIR: %[[Y:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["y", init]
-// CIR: %[[R:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["r"]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CIR: %[[X_LOAD:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[Y_LOAD:.*]] = cir.load{{.*}} %[[Y]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -216,7 +216,7 @@ float add5(float x, float y) {
}
// CIR: cir.func{{.*}}@mov
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+// CIR: %[[A:.*]] = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
// CIR: %[[RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [],
@@ -232,8 +232,8 @@ unsigned mov(unsigned x) {
}
// CIR: cir.func{{.*}}@t1
-// CIR: %[[LEN:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
-// CIR: %[[ASM_STRUCT:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__asm_result"]
+// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ASM_STRUCT:.*]] = cir.alloca "__asm_result" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR: %[[LEN_LOAD:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -257,7 +257,7 @@ void t1(int len) {
}
// CIR: cir.func{{.*}}@t2
-// CIR: %[[T:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["t", init]
+// CIR: %[[T:.*]] = cir.alloca "t" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[T]] : !cir.ptr<!u64i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -271,8 +271,8 @@ void t2(unsigned long long t) {
}
// CIR: cir.func{{.*}}@t3
-// CIR: %[[SRC:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["src", init]
-// CIR-NEXT: %[[TMP:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["temp", init]
+// CIR: %[[SRC:.*]] = cir.alloca "src" {{.*}} init !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR-NEXT: %[[TMP:.*]] = cir.alloca "temp" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR-NEXT: cir.store
// CIR-NEXT: cir.store
// CIR-NEXT: %[[SRC_LOAD:.*]] = cir.load align(8) %[[SRC]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
@@ -291,8 +291,8 @@ void t3(unsigned char *src, unsigned long long temp) {
}
// CIR: cir.func{{.*}}@t4
-// CIR: %[[A:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["a"] {alignment = 8 : i64}
-// CIR: %[[B:.*]] = cir.alloca !rec_reg, !cir.ptr<!rec_reg>, ["b"] {alignment = 8 : i64}
+// CIR: %[[A:.*]] = cir.alloca "a" align(8) !u64i -> !cir.ptr<!u64i>
+// CIR: %[[B:.*]] = cir.alloca "b" align(8) !rec_reg -> !cir.ptr<!rec_reg>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [%[[A]] : !cir.ptr<!u64i> (maybe_memory), %[[B]] : !cir.ptr<!rec_reg> (maybe_memory)],
@@ -310,7 +310,7 @@ void t4(void) {
}
// CIR: cir.func{{.*}}@t5
-// CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[FUNC:.*]] = cir.get_global @t5 : !cir.ptr<!cir.func<(!s32i)>>
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -344,7 +344,7 @@ void t6(void) {
}
// CIR: cir.func{{.*}}@t7
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %0 : !cir.ptr<!s32i>, !s32i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -376,7 +376,7 @@ void t8(void) {
}
// CIR: cir.func{{.*}}@t9
-// CIR: %[[A:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -393,7 +393,7 @@ unsigned t9(unsigned int a) {
}
// CIR: cir.func{{.*}}@t10
-// CIR: %[[R:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["r", init]
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[R_LOAD:.*]] = cir.load align(4) %[[R]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[ZERO1:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[ZERO2:.*]] = cir.const #cir.int<0> : !s32i
@@ -415,8 +415,8 @@ void t10(int r) {
}
// CIR: cir.func{{.*}}@t11
-// CIR: %[[INPUT:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, ["input", init]
-// CIR: %[[OUTPUT:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["output"]
+// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init !s8i -> !cir.ptr<!s8i>
+// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} !u32i -> !cir.ptr<!u32i>
// CIR: %[[INPUT_LOAD:.*]] = cir.load align(1) %[[INPUT]] : !cir.ptr<!s8i>, !s8i
// CIR: %[[INPUT_CAST:.*]] = cir.cast integral %[[INPUT_LOAD]] : !s8i -> !u32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -447,8 +447,8 @@ unsigned t11(signed char input) {
}
// CIR: cir.func{{.*}}@t12
-// CIR: %[[INPUT:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["input", init]
-// CIR: %[[OUTPUT:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["output"]
+// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} !u8i -> !cir.ptr<!u8i>
// CIR: %[[INPUT_LOAD:.*]] = cir.load align(4) %[[INPUT]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -475,8 +475,8 @@ unsigned char t12(unsigned input) {
}
// CIR: cir.func{{.*}}@t13
-// CIR: %[[INPUT:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["input", init]
-// CIR: %[[OUTPUT:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["output"]
+// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} !u8i -> !cir.ptr<!u8i>
// CIR: %[[INPUT_LOAD:.*]] = cir.load align(4) %[[INPUT]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -524,8 +524,8 @@ struct large {
};
// CIR: cir.func{{.*}}@t15
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[LARGE:.*]] = cir.alloca !cir.ptr<!rec_large>, !cir.ptr<!cir.ptr<!rec_large>>, ["P", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[LARGE:.*]] = cir.alloca "P" {{.*}} init !cir.ptr<!rec_large> -> !cir.ptr<!cir.ptr<!rec_large>>
// CIR: %[[LARGE_LOAD:.*]] = cir.load deref align(8) %1 : !cir.ptr<!cir.ptr<!rec_large>>, !cir.ptr<!rec_large>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %0 : !cir.ptr<!s32i>, !s32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -549,8 +549,8 @@ unsigned long t15(int x, struct large *P) {
}
// CIR: cir.func{{.*}}@t16
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[B_LOAD:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -576,7 +576,7 @@ int t16(void) {
}
// CIR: cir.func{{.*}}@t17
-// CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"]
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[I]] : !cir.ptr<!s32i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -591,10 +591,10 @@ void t17(void) {
}
// CIR: cir.func{{.*}}@t18
-// CIR: %[[DATA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["data", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
-// CIR: %[[ASM_RES_VAR:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__asm_result"]
+// CIR: %[[DATA:.*]] = cir.alloca "data" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ASM_RES_VAR:.*]] = cir.alloca "__asm_result" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR: %[[DATA_LOAD:.*]] = cir.load align(4) %[[DATA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -641,9 +641,9 @@ int t18(unsigned data) {
}
// CIR: cir.func{{.*}}@t19
-// CIR: %[[DATA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["data", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
+// CIR: %[[DATA:.*]] = cir.alloca "data" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[DATA_LOAD:.*]] = cir.load align(4) %[[DATA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -669,9 +669,9 @@ int t19(unsigned data) {
// skip t20 and t21: long double is not supported
// CIR: cir.func{{.*}}@t22
-// CIR: %[[LA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["la", init]
-// CIR: %[[LB:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["lb", init]
-// CIR: %[[BIGRES:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["bigres"]
+// CIR: %[[LA:.*]] = cir.alloca "la" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[LB:.*]] = cir.alloca "lb" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[BIGRES:.*]] = cir.alloca "bigres" {{.*}} !u32i -> !cir.ptr<!u32i>
// CIR: %[[LA_LOAD:.*]] = cir.load align(4) %[[LA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[LB_LOAD:.*]] = cir.load align(4) %[[LB]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -701,9 +701,9 @@ unsigned char t22(unsigned char a, unsigned char b) {
}
// CIR: cir.func{{.*}}@t23
-// CIR: %[[LA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["la", init]
-// CIR: %[[LB:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["lb", init]
-// CIR: %[[RES:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["res"]
+// CIR: %[[LA:.*]] = cir.alloca "la" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[LB:.*]] = cir.alloca "lb" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[RES:.*]] = cir.alloca "res" {{.*}} !u8i -> !cir.ptr<!u8i>
// CIR: %[[LA_LOAD:.*]] = cir.load align(4) %[[LA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[LB_LOAD:.*]] = cir.load align(4) %[[LB]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -733,8 +733,8 @@ unsigned char t23(unsigned char a, unsigned char b) {
}
// CIR: cir.func{{.*}}@t24
-// CIR: %[[C:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, ["c", init]
-// CIR: %[[ADDR:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["addr"]
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} init !s8i -> !cir.ptr<!s8i>
+// CIR: %[[ADDR:.*]] = cir.alloca "addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[C_LOAD:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!s8i>, !s8i
// CIR: %[[C_LOAD_CAST:.*]] = cir.cast integral %[[C_LOAD]] : !s8i -> !u64i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -830,7 +830,7 @@ void t29(void) {
}
// CIR: cir.func{{.*}}@t30
-// CIR: %[[LEN:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
+// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[LEN_LOAD:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[LEN]] : !cir.ptr<!s32i> (maybe_memory)],
@@ -847,7 +847,7 @@ void t30(int len) {
}
// CIR: cir.func{{.*}}@t31
-// CIR: %[[LEN:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
+// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[LEN_LOAD:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[LEN_LOAD2:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.asm(x86_att,
@@ -868,8 +868,8 @@ void t31(int len) {
//t32 skipped: no goto
// CIR: cir.func{{.*}}@t33
-// CIR: %[[PTR:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init]
-// CIR: %[[RET:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ret"]
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[RET:.*]] = cir.alloca "ret" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[PTR_LOAD:.*]] = cir.load align(8) %0 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
diff --git a/clang/test/CIR/CodeGen/inline-cxx-func.cpp b/clang/test/CIR/CodeGen/inline-cxx-func.cpp
index 3e57483604dae..39e798ccc25a4 100644
--- a/clang/test/CIR/CodeGen/inline-cxx-func.cpp
+++ b/clang/test/CIR/CodeGen/inline-cxx-func.cpp
@@ -18,8 +18,8 @@ struct S {
// OGCG: %struct.S = type { i32 }
// CIR: cir.func{{.*}} @_ZN1S10InlineFuncEv(%arg0: !cir.ptr<!rec_S> {{.*}}) -> (!s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["this", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: %[[MEMBER_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "Member"} : !cir.ptr<!rec_S> -> !cir.ptr<!s32i>
@@ -47,7 +47,7 @@ void use() {
}
// CIR: cir.func{{.*}} @_Z3usev()
-// CIR: %[[S_ADDR:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s"]
+// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: %[[RET_VAL:.*]] = cir.call @_ZN1S10InlineFuncEv(%[[S_ADDR]]) : (!cir.ptr<!rec_S> {{.*}}) -> (!s32i {{.*}})
// CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/instantiate-init.cpp b/clang/test/CIR/CodeGen/instantiate-init.cpp
index f7ecd0c4b80b4..d2e1ac65ee86f 100644
--- a/clang/test/CIR/CodeGen/instantiate-init.cpp
+++ b/clang/test/CIR/CodeGen/instantiate-init.cpp
@@ -24,9 +24,9 @@ void init_vec_using_initalizer_list() {
Vector vec = {0, 1, 2};
}
-// CIR: %[[VEC_ADDR:.*]] = cir.alloca !rec_Vector, !cir.ptr<!rec_Vector>, ["vec", init]
-// CIR: %[[AGG_ADDR:.*]] = cir.alloca !rec_std3A3Ainitializer_list3Cint3E, !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>, ["agg.tmp0"]
-// CIR: %[[INIT_LIST_ADDR:.*]] = cir.alloca !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>>, ["ref.tmp0"]
+// CIR: %[[VEC_ADDR:.*]] = cir.alloca "vec" {{.*}} init !rec_Vector -> !cir.ptr<!rec_Vector>
+// CIR: %[[AGG_ADDR:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3Ainitializer_list3Cint3E -> !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>
+// CIR: %[[INIT_LIST_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[INIT_LIST_PTR:.*]] = cir.cast array_to_ptrdecay %[[INIT_LIST_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: %[[CONST_S32_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store {{.*}} %[[CONST_S32_0]], %[[INIT_LIST_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/kr-func-promote.c b/clang/test/CIR/CodeGen/kr-func-promote.c
index 03c0c3170966d..cbbdada47754b 100644
--- a/clang/test/CIR/CodeGen/kr-func-promote.c
+++ b/clang/test/CIR/CodeGen/kr-func-promote.c
@@ -6,7 +6,7 @@
// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG
// CIR: cir.func {{.*}}@foo(%arg0: !s32i
-// CIR: %0 = cir.alloca !s16i, !cir.ptr<!s16i>, ["x", init]
+// CIR: %0 = cir.alloca "x" {{.*}} init !s16i -> !cir.ptr<!s16i>
// CIR: %1 = cir.cast integral %arg0 : !s32i -> !s16i
// CIR: cir.store %1, %0 : !s16i, !cir.ptr<!s16i>
// expected-warning at +1 {{a function definition without a prototype is deprecated}}
@@ -24,7 +24,7 @@ void foo(x) short x; {}
// OGCG: store i16 %[[X]], ptr %[[X_PTR]], align 2
// CIR: cir.func{{.*}}no_proto dso_local @bar(%arg0: !cir.double
-// CIR: %0 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
+// CIR: %0 = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CIR: %1 = cir.cast floating %arg0 : !cir.double -> !cir.float
// CIR: cir.store %1, %0 : !cir.float, !cir.ptr<!cir.float>
// expected-warning at +1 {{a function definition without a prototype is deprecated}}
diff --git a/clang/test/CIR/CodeGen/label-values.c b/clang/test/CIR/CodeGen/label-values.c
index fcee8d3688708..5c794a086d1e1 100644
--- a/clang/test/CIR/CodeGen/label-values.c
+++ b/clang/test/CIR/CodeGen/label-values.c
@@ -12,7 +12,7 @@ void A(void) {
return;
}
// CIR: cir.func {{.*}} @A
-// CIR: [[PTR:%.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init] {alignment = 8 : i64}
+// CIR: [[PTR:%.*]] = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: [[BLOCK:%.*]] = cir.block_address <@A, "LABEL_A"> : !cir.ptr<!void>
// CIR: cir.store align(8) [[BLOCK]], [[PTR]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: [[BLOCKADD:%.*]] = cir.load align(8) [[PTR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
@@ -54,7 +54,7 @@ void B(void) {
}
// CIR: cir.func {{.*}} @B()
-// CIR: [[PTR:%.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init] {alignment = 8 : i64}
+// CIR: [[PTR:%.*]] = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: cir.br ^bb1
// CIR: ^bb1: // 2 preds: ^bb0, ^bb2
// CIR: cir.label "LABEL_B"
@@ -155,9 +155,9 @@ void D(void) {
}
// CIR: cir.func {{.*}} @D
-// CIR: %[[PTR:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init]
-// CIR: %[[PTR2:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr2", init]
-// CIR: %[[PTR3:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr3", init]
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[PTR2:.*]] = cir.alloca "ptr2" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[PTR3:.*]] = cir.alloca "ptr3" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[BLK1:.*]] = cir.block_address <@D, "LABEL_A"> : !cir.ptr<!void>
// CIR: cir.store align(8) %[[BLK1]], %[[PTR]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[BLK2:.*]] = cir.block_address <@D, "LABEL_A"> : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/label.c b/clang/test/CIR/CodeGen/label.c
index db35168f61ec1..5cc53c35c31f6 100644
--- a/clang/test/CIR/CodeGen/label.c
+++ b/clang/test/CIR/CodeGen/label.c
@@ -179,7 +179,7 @@ void foo() {
// CIR: cir.func {{.*}} @foo
// CIR: cir.scope {
-// CIR: %0 = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["agg.tmp0"]
+// CIR: %0 = cir.alloca "agg.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.br ^bb1
// CIR: ^bb1:
// CIR: cir.label "label"
diff --git a/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp b/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp
index 3bd642a4b9ee4..d44e77c617960 100644
--- a/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp
+++ b/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp
@@ -12,7 +12,7 @@ void array() {
[=]() { return first;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_0clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FIRST_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "first"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.float>
// CIR: %[[GET_FIRST:.*]] = cir.load {{.*}}%[[FIRST_MEM]] : !cir.ptr<!cir.float>, !cir.float
@@ -25,7 +25,7 @@ void array() {
[&]() { return second;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_1clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[SECOND_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "second"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[GET_SECOND:.*]] = cir.load {{.*}}%[[SECOND_MEM]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
@@ -40,7 +40,7 @@ void array() {
[third]() { return third;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_2clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[THIRD_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "third"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.float>
// CIR: %[[GET_THIRD:.*]] = cir.load {{.*}}%[[THIRD_MEM]] : !cir.ptr<!cir.float>, !cir.float
@@ -53,7 +53,7 @@ void array() {
[&fourth]() { return fourth;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_3clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FOURTH_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "fourth"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[GET_FOURTH:.*]] = cir.load {{.*}}%[[FOURTH_MEM]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
@@ -76,7 +76,7 @@ void Struct() {
[=]() { return first;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_0clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FIRST_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "first"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_FIRST:.*]] = cir.load {{.*}}%[[FIRST_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -88,7 +88,7 @@ void Struct() {
// LLVM: %[[GET_FIRST:.*]] = load i32, ptr %[[FIRST_MEM]]
[&]() { return second;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_1clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[SECOND_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "second"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_SECOND:.*]] = cir.load {{.*}}%[[SECOND_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -102,7 +102,7 @@ void Struct() {
// LLVM: %[[DEREF:.*]] = load i32, ptr %[[GET_SECOND]]
[third]() { return third;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_2clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[THIRD_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "third"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_THIRD:.*]] = cir.load {{.*}}%[[THIRD_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -114,7 +114,7 @@ void Struct() {
// LLVM: %[[GET_THIRD:.*]] = load i32, ptr %[[THIRD_MEM]]
[&fourth]() { return fourth;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_3clEv
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FOURTH_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "fourth"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_FOURTH:.*]] = cir.load {{.*}}%[[FOURTH_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -135,7 +135,7 @@ void StructNested() {
auto outer = [&]() {
[=]() { return first;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FIRST_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "first"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_FIRST:.*]] = cir.load {{.*}}%[[FIRST_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -147,7 +147,7 @@ void StructNested() {
// LLVM: %[[GET_FIRST:.*]] = load i32, ptr %[[FIRST_MEM]]
[&]() { return second;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE0_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[SECOND_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "second"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_SECOND:.*]] = cir.load {{.*}}%[[SECOND_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -161,7 +161,7 @@ void StructNested() {
// LLVM: %[[DEREF:.*]] = load i32, ptr %[[GET_SECOND]]
[third]() { return third;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE1_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[THIRD_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "third"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_THIRD:.*]] = cir.load {{.*}}%[[THIRD_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -173,7 +173,7 @@ void StructNested() {
// LLVM: %[[GET_THIRD:.*]] = load i32, ptr %[[THIRD_MEM]]
[&fourth]() { return fourth;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE2_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[LAMBDA_TY:.*]]>, !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, ["this", init]
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FOURTH_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "fourth"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_FOURTH:.*]] = cir.load {{.*}}%[[FOURTH_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/lambda-dtor-field.cpp b/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
index 23eda33702992..73b4ea3421ca7 100644
--- a/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
+++ b/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
@@ -18,7 +18,7 @@ void capture_one(S s) {
}
// CIR-LABEL: @_Z11capture_one1S
-// CIR: %[[LAM:.*]] = cir.alloca !rec_anon{{.*}}, {{.*}} ["lam", init]
+// CIR: %[[LAM:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
// CIR: %[[FIELD:.*]] = cir.get_member %[[LAM]][0] {name = "s"}
// CIR: cir.call @_ZN1SC1ERKS_(%[[FIELD]],
// CIR: cir.cleanup.scope {
@@ -54,7 +54,7 @@ void capture_two(S a, S b) {
}
// CIR-LABEL: @_Z11capture_two1SS_
-// CIR: %[[LAM2:.*]] = cir.alloca !rec_anon{{.*}}, {{.*}} ["lam", init]
+// CIR: %[[LAM2:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
// CIR: %[[FA:.*]] = cir.get_member %[[LAM2]][0] {name = "a"}
// CIR: cir.call @_ZN1SC1ERKS_(%[[FA]],
// CIR: cir.cleanup.scope {
@@ -107,7 +107,7 @@ void capture_mixed(int n, S s) {
}
// CIR-LABEL: @_Z13capture_mixedi1S
-// CIR: %[[LAM3:.*]] = cir.alloca !rec_anon{{.*}}, {{.*}} ["lam", init]
+// CIR: %[[LAM3:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
// CIR: %[[FN:.*]] = cir.get_member %[[LAM3]][0] {name = "n"}
// CIR: cir.load
// CIR: cir.store
@@ -154,8 +154,8 @@ void capture_local() {
}
// CIR-LABEL: @_Z13capture_localv
-// CIR: %[[S4:.*]] = cir.alloca !rec_S, {{.*}} ["s", init]
-// CIR: %[[LAM4:.*]] = cir.alloca !rec_anon{{.*}}, {{.*}} ["lam", init]
+// CIR: %[[S4:.*]] = cir.alloca "s" {{.*}} init !rec_S
+// CIR: %[[LAM4:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
// CIR: cir.call @_ZN1SC1Ev(%[[S4]])
// CIR: cir.cleanup.scope {
// CIR: %[[FL:.*]] = cir.get_member %[[LAM4]][0] {name = "s"}
@@ -214,8 +214,8 @@ void stmt_expr_return(bool cond) {
}
// CIR-LABEL: @_Z16stmt_expr_returnb
-// CIR: %[[LAM5:.*]] = cir.alloca !rec_anon{{.*}}, {{.*}} ["lam", init]
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.isactive"]
+// CIR: %[[LAM5:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[FA5:.*]] = cir.get_member %[[LAM5]][0] {name = "a"}
// CIR: cir.call @_ZN1SC1Ei(%[[FA5]],
// CIR: %[[TRUE:.*]] = cir.const #true
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
index 830e80034bfe7..91b90529be165 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
@@ -21,9 +21,9 @@ S agg_invoker() {
// CIR-LABEL: cir.func no_inline internal private dso_local @_ZZ11agg_invokervEN3$_08__invokeEi
// CIR-SAME: (%[[I_ARG:.*]]: !s32i {{.*}}) -> !rec_S
-// CIR: %[[I_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval"]
-// CIR: %[[UNUSED:.*]] = cir.alloca !rec_anon{{[^,]*}}, {{.*}} ["unused.capture"]
+// CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[UNUSED:.*]] = cir.alloca "unused.capture" {{.*}} !rec_anon{{[^,]*}}
// CIR-NOT: cir.alloca {{.*}} ["agg.tmp
// CIR: cir.store %[[I_ARG]], %[[I_ALLOCA]]
// CIR: %[[I:.*]] = cir.load{{.*}} %[[I_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
index d9be0a5521c19..0cd6f31d31d9f 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
@@ -38,9 +38,9 @@ int g3() {
// lambda operator()
// CIR: cir.func no_inline lambda internal private dso_local @_ZZ2g3vENK3$_0clERKi(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G3:.*]]> {{.*}}, %[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}})
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<![[REC_LAM_G3]]>, !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>, ["this", init]
-// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca {{.*}} ["i", init, const]
-// CIR: %[[RETVAL:.*]] = cir.alloca {{.*}} ["__retval"]
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G3]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
+// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}}
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: cir.store %[[REF_I_ARG]], %[[REF_I_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
@@ -67,9 +67,9 @@ int g3() {
// lambda invoker
// CIR: cir.func no_inline internal private dso_local @_ZZ2g3vEN3$_08__invokeERKi(%[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}}) -> (!s32i{{.*}}) {{.*}} {
-// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca {{.*}} ["i", init, const]
-// CIR: %[[RETVAL:.*]] = cir.alloca {{.*}} ["__retval"]
-// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca ![[REC_LAM_G3]], !cir.ptr<![[REC_LAM_G3]]>, ["unused.capture"]
+// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}}
+// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "unused.capture" {{.*}} ![[REC_LAM_G3]] -> !cir.ptr<![[REC_LAM_G3]]>
// CIR: cir.store %[[REF_I_ARG]], %[[REF_I_ALLOCA]]
// CIR: %[[REF_I:.*]] = cir.load{{.*}} %[[REF_I_ALLOCA]]
// CIR: %[[LAM_RESULT:.*]] = cir.call @_ZZ2g3vENK3$_0clERKi(%2, %3) : (!cir.ptr<![[REC_LAM_G3]]> {{.*}}, !cir.ptr<!s32i> {{.*}}) -> (!s32i{{.*}})
@@ -92,8 +92,8 @@ int g3() {
// lambda operator int (*)(int const&)()
// CIR: cir.func no_inline internal private dso_local @_ZZ2g3vENK3$_0cvPFiRKiEEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G3]]> {{.*}}) -> (!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>{{.*}}){{.*}} {
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<![[REC_LAM_G3]]>, !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>, ["__retval"]
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G3]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
// CIR: %[[INVOKER:.*]] = cir.get_global @_ZZ2g3vEN3$_08__invokeERKi : !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>
@@ -113,11 +113,11 @@ int g3() {
// In OGCG, the _ZZ2g3vENK3$_0cvPFiRKiEEv function is emitted just after the _Z2g3v function, see above.
// CIR: cir.func{{.*}} @_Z2g3v() -> (!s32i{{.*}}){{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[FN_ADDR:.*]] = cir.alloca !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>, ["fn", init]
-// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca ![[REC_LAM_G3]], !cir.ptr<![[REC_LAM_G3]]>, ["ref.tmp0"]
-// CIR: %[[TASK:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["task", init]
-// CIR: %[[REF_TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp1", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[FN_ADDR:.*]] = cir.alloca "fn" {{.*}} init !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
+// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_G3]] -> !cir.ptr<![[REC_LAM_G3]]>
+// CIR: %[[TASK:.*]] = cir.alloca "task" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} init !s32i -> !cir.ptr<!s32i>
// 1. Use `operator int (*)(int const&)()` to retrieve the fnptr to `__invoke()`.
// CIR: %[[OPERATOR_RESULT:.*]] = cir.call @_ZZ2g3vENK3$_0cvPFiRKiEEv(%[[LAM_ALLOCA]]){{.*}}
@@ -162,8 +162,8 @@ void use_void_lambda() {
// lambda operator()
// CIR: cir.func no_inline lambda internal private dso_local @_ZZ15use_void_lambdavENK3$_0clIiEEDaT_(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_VOID_LAMBDA:.*]]> {{.*}}, %[[X_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>, !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>, ["this", init]
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_VOID_LAMBDA]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: cir.store %[[X_ARG]], %[[X]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
@@ -171,8 +171,8 @@ void use_void_lambda() {
// lambda invoker
// CIR: cir.func no_inline internal private dso_local @_ZZ15use_void_lambdavEN3$_08__invokeIiEEDaT_(%[[X_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[X_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[UNUSED_CAPTURE:.*]] = cir.alloca ![[REC_LAM_VOID_LAMBDA]], !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>, ["unused.capture"]
+// CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[UNUSED_CAPTURE:.*]] = cir.alloca "unused.capture" {{.*}} ![[REC_LAM_VOID_LAMBDA]] -> !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>
// CIR: cir.store %[[X_ARG]], %[[X_ALLOCA]]
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ALLOCA]]
// CIR: cir.call @_ZZ15use_void_lambdavENK3$_0clIiEEDaT_(%[[UNUSED_CAPTURE]], %[[X]]) : (!cir.ptr<![[REC_LAM_VOID_LAMBDA]]> {{.*}}, !s32i {{.*}}) -> ()
@@ -180,8 +180,8 @@ void use_void_lambda() {
// lambda operator void (*)(int)()
// CIR: cir.func no_inline internal private dso_local @_ZZ15use_void_lambdavENK3$_0cvPFDaT_EIiEEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_VOID_LAMBDA]]> {{.*}}) -> (!cir.ptr<!cir.func<(!s32i)>>{{.*}})
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>, !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i)>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>, ["__retval"]
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_VOID_LAMBDA]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i)>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
// CIR: %[[INVOKER:.*]] = cir.get_global @_ZZ15use_void_lambdavEN3$_08__invokeIiEEDaT_ : !cir.ptr<!cir.func<(!s32i)>>
@@ -190,8 +190,8 @@ void use_void_lambda() {
// CIR: cir.return %[[RET]]
// CIR: cir.func no_inline dso_local @_Z15use_void_lambdav()
-// CIR: %[[L_ALLOCA:.*]] = cir.alloca ![[REC_LAM_VOID_LAMBDA]], !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>, ["L"]
-// CIR: %[[P_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.func<(!s32i)>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>, ["p", init]
+// CIR: %[[L_ALLOCA:.*]] = cir.alloca "L" {{.*}} ![[REC_LAM_VOID_LAMBDA]] -> !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>
+// CIR: %[[P_ALLOCA:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i)>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
// CIR: %[[LAMBDA:.*]] = cir.call @_ZZ15use_void_lambdavENK3$_0cvPFDaT_EIiEEv(%[[L_ALLOCA]])
// CIR: cir.store{{.*}} %[[LAMBDA]], %[[P_ALLOCA]]
// CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp
index 0faa3bc9b8441..b064fb3195bbf 100644
--- a/clang/test/CIR/CodeGen/lambda.cpp
+++ b/clang/test/CIR/CodeGen/lambda.cpp
@@ -15,7 +15,7 @@ void use_global_lambda() {
// CIR: cir.global "private" internal dso_local @global_lambda = #cir.undef : ![[REC_LAM_GLOBAL_LAMBDA:.*]] {alignment = 1 : i64}
// CIR: cir.func {{.*}} lambda internal private dso_local @_ZNK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]> {{.*}})
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]>, !cir.ptr<!cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]>>, ["this", init]
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS]]
// CIR: cir.load %[[THIS]]
//
@@ -47,13 +47,13 @@ void fn() {
}
// CIR: cir.func {{.*}} lambda internal private dso_local @_ZZ2fnvENK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_FN_A:.*]]> {{.*}})
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<![[REC_LAM_FN_A]]>, !cir.ptr<!cir.ptr<![[REC_LAM_FN_A]]>>, ["this", init]
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_FN_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_FN_A]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS]]
// CIR: cir.load %[[THIS]]
// CIR: cir.return
// CIR: cir.func {{.*}} @_Z2fnv()
-// CIR: %[[A:.*]] = cir.alloca ![[REC_LAM_FN_A]], !cir.ptr<![[REC_LAM_FN_A]]>, ["a"]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} ![[REC_LAM_FN_A]] -> !cir.ptr<![[REC_LAM_FN_A]]>
// CIR: cir.call @_ZZ2fnvENK3$_0clEv(%[[A]])
// LLVM: define internal void @"_ZZ2fnvENK3$_0clEv"(ptr {{.*}} %[[THIS_ARG:.*]])
@@ -86,7 +86,7 @@ void l0() {
}
// CIR: cir.func {{.*}} lambda internal private dso_local @_ZZ2l0vENK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_L0_A:.*]]> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<![[REC_LAM_L0_A]]>, !cir.ptr<!cir.ptr<![[REC_LAM_L0_A]]>>, ["this", init] {alignment = 8 : i64}
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init !cir.ptr<![[REC_LAM_L0_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_L0_A]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[I_ADDR_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
@@ -100,8 +100,8 @@ void l0() {
// CIR: cir.return
// CIR: cir.func {{.*}} @_Z2l0v()
-// CIR: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"]
-// CIR: %[[A:.*]] = cir.alloca ![[REC_LAM_L0_A]], !cir.ptr<![[REC_LAM_L0_A]]>, ["a", init]
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init ![[REC_LAM_L0_A]] -> !cir.ptr<![[REC_LAM_L0_A]]>
// CIR: %[[I_ADDR:.*]] = cir.get_member %[[A]][0] {name = "i"}
// CIR: cir.store{{.*}} %[[I]], %[[I_ADDR]]
// CIR: cir.call @_ZZ2l0vENK3$_0clEv(%[[A]])
@@ -158,8 +158,8 @@ auto g() {
}
// CIR: cir.func {{.*}} @_Z1gv() -> ![[REC_LAM_G:.*]] attributes {{{.*}}nothrow} {
-// CIR: %[[RETVAL:.*]] = cir.alloca ![[REC_LAM_G]], !cir.ptr<![[REC_LAM_G]]>, ["__retval"]
-// CIR: %[[I_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} ![[REC_LAM_G]] -> !cir.ptr<![[REC_LAM_G]]>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TWELVE:.*]] = cir.const #cir.int<12> : !s32i
// CIR: cir.store{{.*}} %[[TWELVE]], %[[I_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[I_ADDR_ADDR:.*]] = cir.get_member %[[RETVAL]][0] {name = "i"} : !cir.ptr<![[REC_LAM_G]]> -> !cir.ptr<!cir.ptr<!s32i>>
@@ -200,8 +200,8 @@ auto g2() {
// Should be same as above because of NRVO
// CIR: cir.func {{.*}} @_Z2g2v() -> ![[REC_LAM_G2:.*]] attributes {{{.*}}nothrow} {
-// CIR: %[[RETVAL:.*]] = cir.alloca ![[REC_LAM_G2]], !cir.ptr<![[REC_LAM_G2]]>, ["__retval", init]
-// CIR: %[[I_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} init ![[REC_LAM_G2]] -> !cir.ptr<![[REC_LAM_G2]]>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TWELVE:.*]] = cir.const #cir.int<12> : !s32i
// CIR: cir.store{{.*}} %[[TWELVE]], %[[I_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[I_ADDR_ADDR:.*]] = cir.get_member %[[RETVAL]][0] {name = "i"} : !cir.ptr<![[REC_LAM_G2]]> -> !cir.ptr<!cir.ptr<!s32i>>
@@ -233,8 +233,8 @@ int f() {
}
// CIR:cir.func {{.*}} lambda internal private dso_local @_ZZ2g2vENK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G2]]> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<![[REC_LAM_G2]]>, !cir.ptr<!cir.ptr<![[REC_LAM_G2]]>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G2]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G2]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[ONE_HUNDRED:.*]] = cir.const #cir.int<100> : !s32i
@@ -251,8 +251,8 @@ int f() {
// CIR: cir.return %[[RET]]
// CIR: cir.func {{.*}} @_Z1fv() -> (!s32i{{.*}})
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[TMP:.*]] = cir.alloca ![[REC_LAM_G2]], !cir.ptr<![[REC_LAM_G2]]>, ["ref.tmp0"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_G2]] -> !cir.ptr<![[REC_LAM_G2]]>
// CIR: %[[G2:.*]] = cir.call @_Z2g2v() : () -> ![[REC_LAM_G2]]
// CIR: cir.store{{.*}} %[[G2]], %[[TMP]]
// CIR: %[[RESULT:.*]] = cir.call @_ZZ2g2vENK3$_0clEv(%[[TMP]])
@@ -327,8 +327,8 @@ struct A {
// lambda operator() in foo()
// CIR: cir.func {{.*}} lambda comdat linkonce_odr @_ZZN1A3fooEvENKUlvE_clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_A:[^>]*]]> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<![[REC_LAM_A]]>, !cir.ptr<!cir.ptr<![[REC_LAM_A]]>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_A]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
// CIR: %[[STRUCT_A:.*]] = cir.get_member %[[THIS]][0] {name = "this"}
@@ -354,9 +354,9 @@ struct A {
// A::foo()
// CIR: cir.func {{.*}} @_ZN1A3fooEv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_A> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[LAM_ADDR:.*]] = cir.alloca ![[REC_LAM_A]], !cir.ptr<![[REC_LAM_A]]>, ["ref.tmp0"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[LAM_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_A]] -> !cir.ptr<![[REC_LAM_A]]>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load deref %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[STRUCT_A:.*]] = cir.get_member %[[LAM_ADDR]][0] {name = "this"} : !cir.ptr<![[REC_LAM_A]]> -> !cir.ptr<!rec_A>
@@ -391,8 +391,8 @@ struct A {
// lambda operator() in bar()
// CIR: cir.func {{.*}} @_ZZN1A3barEvENKUlvE_clEv(%[[THIS_ARG2:.*]]: !cir.ptr<![[REC_LAM_PTR_A:[^>]*]]> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<![[REC_LAM_PTR_A]]>, !cir.ptr<!cir.ptr<![[REC_LAM_PTR_A]]>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_PTR_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_PTR_A]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
// CIR: %[[STRUCT_A_ADDR_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "this"}
@@ -420,9 +420,9 @@ struct A {
// A::bar()
// CIR: cir.func {{.*}} @_ZN1A3barEv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_A> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["this", init]
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[LAM_ADDR:.*]] = cir.alloca ![[REC_LAM_PTR_A]], !cir.ptr<![[REC_LAM_PTR_A]]>, ["ref.tmp0"]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[LAM_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_PTR_A]] -> !cir.ptr<![[REC_LAM_PTR_A]]>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[A_ADDR_ADDR:.*]] = cir.get_member %[[LAM_ADDR]][0] {name = "this"} : !cir.ptr<![[REC_LAM_PTR_A]]> -> !cir.ptr<!cir.ptr<!rec_A>>
diff --git a/clang/test/CIR/CodeGen/launder.cpp b/clang/test/CIR/CodeGen/launder.cpp
index 397459c0a7a24..72aacc5966cf7 100644
--- a/clang/test/CIR/CodeGen/launder.cpp
+++ b/clang/test/CIR/CodeGen/launder.cpp
@@ -27,8 +27,8 @@ auto use_derived(Derived *d) {
return __builtin_launder(d);
}
// CIR-LABEL: cir.func{{.*}}@_Z11use_derivedP7Derived
-// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["d", init]
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["__retval"]
+// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: %[[ARG_LOAD:.*]] = cir.load align(8) %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
// CIR: cir.store %[[ARG_LOAD]], %[[RET_ALLOCA]] : !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: %[[RET:.*]] = cir.load %[[RET_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
@@ -48,8 +48,8 @@ auto use_derived(Derived *d) {
// OGCG: ret ptr %[[ARG_LOAD]]
//
// CIR-STRICT-LABEL: cir.func{{.*}}@_Z11use_derivedP7Derived
-// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["d", init]
-// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["__retval"]
+// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR-STRICT: %[[LOAD_ARG:.*]] = cir.load align(8) %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
// CIR-STRICT: %[[LAUNDER:.*]] = cir.launder %[[LOAD_ARG]] : !cir.ptr<!rec_Derived>
// CIR-STRICT: cir.store %[[LAUNDER]], %[[RET_ALLOCA]] : !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>
@@ -76,8 +76,8 @@ auto use_vm(VirtMem *vm) {
return __builtin_launder(vm);
}
// CIR-LABEL: cir.func {{.*}}@_Z6use_vmP7VirtMem
-// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>, ["vm", init]
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>, ["__retval"]
+// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
// CIR: cir.store %[[ARG_LOAD]], %[[RET_ALLOCA]] : !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>
// CIR: %[[RET:.*]] = cir.load %[[RET_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtMem>>, !cir.ptr<!rec_VirtMem>
// CIR: cir.return %[[RET]] : !cir.ptr<!rec_VirtMem>
@@ -96,8 +96,8 @@ auto use_vm(VirtMem *vm) {
// OGCG: ret ptr %[[ARG_LOAD]]
//
// CIR-STRICT-LABEL: cir.func {{.*}}@_Z6use_vmP7VirtMem
-// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>, ["vm", init]
-// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>, ["__retval"]
+// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
// CIR-STRICT: %[[LOAD_ARG:.*]] = cir.load align(8) %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtMem>>, !cir.ptr<!rec_VirtMem>
// CIR-STRICT: %[[LAUNDER:.*]] = cir.launder %[[LOAD_ARG]] : !cir.ptr<!rec_VirtMem>
// CIR-STRICT: cir.store %[[LAUNDER]], %[[RET_ALLOCA]] : !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>
diff --git a/clang/test/CIR/CodeGen/local-vars.cpp b/clang/test/CIR/CodeGen/local-vars.cpp
index ee385170d1e49..57906d91f800f 100644
--- a/clang/test/CIR/CodeGen/local-vars.cpp
+++ b/clang/test/CIR/CodeGen/local-vars.cpp
@@ -27,23 +27,23 @@ void test() {
// CIR: module
// CIR: cir.func{{.*}} @_Z4testv()
-// CIR: %[[I_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
-// CIR: %[[L_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["l", init] {alignment = 8 : i64}
-// CIR: %[[F_PTR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init] {alignment = 4 : i64}
-// CIR: %[[D_PTR:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["d", init] {alignment = 8 : i64}
-// CIR: %[[B1_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b1", init] {alignment = 1 : i64}
-// CIR: %[[B2_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b2", init] {alignment = 1 : i64}
-// CIR: %[[CI_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ci", init, const] {alignment = 4 : i64}
-// CIR: %[[CL_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["cl", init, const] {alignment = 8 : i64}
-// CIR: %[[CF_PTR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["cf", init, const] {alignment = 4 : i64}
-// CIR: %[[CD_PTR:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["cd", init, const] {alignment = 8 : i64}
-// CIR: %[[CB1_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cb1", init, const] {alignment = 1 : i64}
-// CIR: %[[CB2_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cb2", init, const] {alignment = 1 : i64}
-// CIR: %[[UII_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["uii"] {alignment = 4 : i64}
-// CIR: %[[UIL_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["uil"] {alignment = 8 : i64}
-// CIR: %[[UIF_PTR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["uif"] {alignment = 4 : i64}
-// CIR: %[[UID_PTR:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["uid"] {alignment = 8 : i64}
-// CIR: %[[UIB_PTR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["uib"] {alignment = 1 : i64}
+// CIR: %[[I_PTR:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[L_PTR:.*]] = cir.alloca "l" align(8) init !s64i -> !cir.ptr<!s64i>
+// CIR: %[[F_PTR:.*]] = cir.alloca "f" align(4) init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[D_PTR:.*]] = cir.alloca "d" align(8) init !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[B1_PTR:.*]] = cir.alloca "b1" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[B2_PTR:.*]] = cir.alloca "b2" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CI_PTR:.*]] = cir.alloca "ci" align(4) init const !s32i -> !cir.ptr<!s32i>
+// CIR: %[[CL_PTR:.*]] = cir.alloca "cl" align(8) init const !s64i -> !cir.ptr<!s64i>
+// CIR: %[[CF_PTR:.*]] = cir.alloca "cf" align(4) init const !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[CD_PTR:.*]] = cir.alloca "cd" align(8) init const !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[CB1_PTR:.*]] = cir.alloca "cb1" align(1) init const !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CB2_PTR:.*]] = cir.alloca "cb2" align(1) init const !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[UII_PTR:.*]] = cir.alloca "uii" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR: %[[UIL_PTR:.*]] = cir.alloca "uil" align(8) !s64i -> !cir.ptr<!s64i>
+// CIR: %[[UIF_PTR:.*]] = cir.alloca "uif" align(4) !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[UID_PTR:.*]] = cir.alloca "uid" align(8) !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[UIB_PTR:.*]] = cir.alloca "uib" align(1) !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store align(4) %[[ONE]], %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s64i
@@ -146,13 +146,13 @@ void value_init() {
}
// CIR: cir.func{{.*}} @_Z10value_initv()
-// CIR: %[[F_PTR:.+]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
-// CIR: %[[B_PTR:.+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
-// CIR: %[[I_PTR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
-// CIR: %[[F2_PTR:.+]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f2", init]
-// CIR: %[[B2_PTR:.+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b2", init]
-// CIR: %[[I2_PTR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i2", init]
-// CIR: %[[S_PTR:.+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["scalar_value_init_expr", init]
+// CIR: %[[F_PTR:.+]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B_PTR:.+]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[I_PTR:.+]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[F2_PTR:.+]] = cir.alloca "f2" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[B2_PTR:.+]] = cir.alloca "b2" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[I2_PTR:.+]] = cir.alloca "i2" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[S_PTR:.+]] = cir.alloca "scalar_value_init_expr" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[ZEROF1:.+]] = cir.const #cir.fp<0.000000e+00> : !cir.float
// CIR: cir.store{{.*}} %[[ZEROF1]], %[[F_PTR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: %[[FALSE1:.+]] = cir.const #false
diff --git a/clang/test/CIR/CodeGen/long-double-inc-dec.cpp b/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
index 02a6c10c010b2..fa2f70026452c 100644
--- a/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
+++ b/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
@@ -21,8 +21,8 @@
extern "C" long double do_pre_inc(long double d) {
// CIR-LABEL: @do_pre_inc(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>, ["d", init]
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_pre_inc(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
@@ -47,8 +47,8 @@ extern "C" long double do_pre_inc(long double d) {
}
extern "C" long double do_post_inc(long double d) {
// CIR-LABEL: @do_post_inc(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>, ["d", init]
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_post_inc(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
@@ -74,8 +74,8 @@ extern "C" long double do_post_inc(long double d) {
extern "C" long double do_pre_dec(long double d) {
// CIR-LABEL: @do_pre_dec(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>, ["d", init]
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_pre_dec(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
@@ -100,8 +100,8 @@ extern "C" long double do_pre_dec(long double d) {
}
extern "C" long double do_post_dec(long double d) {
// CIR-LABEL: @do_post_dec(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>, ["d", init]
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.long_double<![[LDTY]]>, !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_post_dec(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp
index e1dbea54e5d1d..58328dc4b977d 100644
--- a/clang/test/CIR/CodeGen/loop.cpp
+++ b/clang/test/CIR/CodeGen/loop.cpp
@@ -55,7 +55,7 @@ void l1() {
// CIR: cir.func{{.*}} @_Z2l1v
// CIR-NEXT: cir.scope {
-// CIR-NEXT: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[ZERO]], %[[I]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.for : cond {
@@ -108,7 +108,7 @@ void l2() {
// CIR-NEXT: cir.condition(%[[TRUE]])
// CIR-NEXT: } body {
// CIR-NEXT: cir.scope {
-// CIR-NEXT: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[ZERO]], %[[I]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: }
@@ -153,7 +153,7 @@ void l3() {
// CIR: cir.func{{.*}} @_Z2l3v
// CIR-NEXT: cir.scope {
-// CIR-NEXT: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: cir.for : cond {
// CIR-NEXT: %[[TRUE:.*]] = cir.const #true
// CIR-NEXT: cir.condition(%[[TRUE]])
@@ -200,12 +200,12 @@ void l4() {
}
// CIR: cir.func{{.*}} @_Z2l4v
-// CIR: %[[A_ADDR:.*]] = cir.alloca {{.*}} ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}}
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca {{.*}} ["__range1", init, const]
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca {{.*}} ["__begin1", init]
-// CIR: %[[END_ADDR:.*]] = cir.alloca {{.*}} ["__end1", init]
-// CIR: %[[N_ADDR:.*]] = cir.alloca {{.*}} ["n", init]
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init
// CIR: cir.store{{.*}} %[[A_ADDR]], %[[RANGE_ADDR]]
// CIR: %[[RANGE_LOAD:.*]] = cir.load{{.*}} %[[RANGE_ADDR]]
// CIR: %[[RANGE_CAST:.*]] = cir.cast array_to_ptrdecay %[[RANGE_LOAD]] : {{.*}}
@@ -310,11 +310,11 @@ void l5() {
// CIR: cir.func{{.*}} @_Z2l5v
// CIR: cir.scope {
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca {{.*}} ["arr", init]
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca {{.*}} ["__range1", init, const]
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca {{.*}} ["__begin1", init]
-// CIR: %[[END_ADDR:.*]] = cir.alloca {{.*}} ["__end1", init]
-// CIR: %[[X_ADDR:.*]] = cir.alloca {{.*}} ["x", init]
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init
// CIR: %[[ARR_INIT:.*]] = cir.get_global @[[L5_ARR]]
// CIR: cir.copy %[[ARR_INIT]] to %[[ARR_ADDR]]
// CIR: cir.store{{.*}} %[[ARR_ADDR]], %[[RANGE_ADDR]]
@@ -507,7 +507,7 @@ void unreachable_after_continue() {
// CIR: cir.condition(%[[TRUE]])
// CIR: } body {
// CIR: cir.scope {
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+// CIR: %[[X:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: cir.continue
// CIR: ^bb1: // no predecessors
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -567,7 +567,7 @@ void unreachable_after_break() {
// CIR: cir.condition(%[[TRUE]])
// CIR: } body {
// CIR: cir.scope {
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+// CIR: %[[X:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: cir.break
// CIR: ^bb1: // no predecessors
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
diff --git a/clang/test/CIR/CodeGen/mem-expr-fn.cpp b/clang/test/CIR/CodeGen/mem-expr-fn.cpp
index c63fbd848236b..64a5c19be959c 100644
--- a/clang/test/CIR/CodeGen/mem-expr-fn.cpp
+++ b/clang/test/CIR/CodeGen/mem-expr-fn.cpp
@@ -12,8 +12,8 @@ struct WithStaticMem {
extern "C" void use(WithStaticMem m) {
// CIR-LABEL: use(
auto x = m.StaticMem;
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca !rec_WithStaticMem, !cir.ptr<!rec_WithStaticMem>, ["m", init]
- // CIR: %[[X_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.func<()>>, !cir.ptr<!cir.ptr<!cir.func<()>>>, ["x", init]
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "m" {{.*}} init !rec_WithStaticMem -> !cir.ptr<!rec_WithStaticMem>
+ // CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !cir.ptr<!cir.func<()>> -> !cir.ptr<!cir.ptr<!cir.func<()>>>
// CIR: cir.store %{{.*}}, %[[ARG_ALLOCA]] : !rec_WithStaticMem, !cir.ptr<!rec_WithStaticMem>
// CIR: %[[GET_STATIC_FUNC:.*]] = cir.get_global @_ZN13WithStaticMem9StaticMemEv : !cir.ptr<!cir.func<()>>
// CIR: cir.store {{.*}}%[[GET_STATIC_FUNC]], %[[X_ALLOCA]] : !cir.ptr<!cir.func<()>>, !cir.ptr<!cir.ptr<!cir.func<()>>>
diff --git a/clang/test/CIR/CodeGen/member-functions.cpp b/clang/test/CIR/CodeGen/member-functions.cpp
index 721e37f5e0cbc..a63b5532f1936 100644
--- a/clang/test/CIR/CodeGen/member-functions.cpp
+++ b/clang/test/CIR/CodeGen/member-functions.cpp
@@ -11,7 +11,7 @@ struct C {
void C::f() {}
// CIR: cir.func{{.*}} @_ZN1C1fEv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_C>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]] : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
// CIR: cir.return
@@ -20,9 +20,9 @@ void C::f() {}
void C::f2(int a, int b) {}
// CIR: cir.func{{.*}} @_ZN1C2f2Eii(%[[THIS_ARG:.*]]: !cir.ptr<!rec_C> {{.*}}, %[[A_ARG:.*]]: !s32i {{.*}}, %[[B_ARG:.*]]: !s32i {{.*}})
-// CIR-NEXT: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init]
-// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[THIS_ARG]], %[[THIS_ADDR]] : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
// CIR-NEXT: cir.store %[[A_ARG]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[B_ARG]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
@@ -37,7 +37,7 @@ void test1() {
}
// CIR: cir.func{{.*}} @_Z5test1v()
-// CIR-NEXT: %[[C_ADDR:.*]] = cir.alloca !rec_C, !cir.ptr<!rec_C>, ["c"]
+// CIR-NEXT: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C -> !cir.ptr<!rec_C>
// CIR-NEXT: cir.call @_ZN1C1fEv(%[[C_ADDR]]) : (!cir.ptr<!rec_C> {{.*}}) -> ()
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
diff --git a/clang/test/CIR/CodeGen/multi-vtable.cpp b/clang/test/CIR/CodeGen/multi-vtable.cpp
index 456d0642751b4..580167013560b 100644
--- a/clang/test/CIR/CodeGen/multi-vtable.cpp
+++ b/clang/test/CIR/CodeGen/multi-vtable.cpp
@@ -140,7 +140,7 @@ void Child::MotherKey() {}
Child::Child() {}
// CIR: cir.func {{.*}} @_ZN5ChildC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Child>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[MOTHER_BASE:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Child> nonnull [0] -> !cir.ptr<!rec_Mother>
diff --git a/clang/test/CIR/CodeGen/new-delete-deactivation.cpp b/clang/test/CIR/CodeGen/new-delete-deactivation.cpp
index 86431113991d8..b120a6ae656fd 100644
--- a/clang/test/CIR/CodeGen/new-delete-deactivation.cpp
+++ b/clang/test/CIR/CodeGen/new-delete-deactivation.cpp
@@ -22,10 +22,10 @@ B makeB();
A *deact_simple() { return new A(makeB()); }
// CIR-LABEL: cir.func {{.*}} @_Z12deact_simplev() -> !cir.ptr<!rec_A>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["__retval"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["__new_result"]
-// CIR: %[[TMP:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp0"]
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.isactive"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
// CIR: %[[TRUE:.*]] = cir.const #true
@@ -106,7 +106,7 @@ A *deact_if(bool cond) {
// CIR-LABEL: cir.func {{.*}} @_Z8deact_ifb
// CIR: cir.if {{.*}} {
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.isactive"]
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
// CIR: %[[TRUE:.*]] = cir.const #true
@@ -162,7 +162,7 @@ A *deact_if(bool cond) {
A *deact_ternary(bool cond) { return (new A(makeB()), cond) ? nullptr : nullptr; }
// CIR-LABEL: cir.func {{.*}} @_Z13deact_ternaryb
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.isactive"]
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
// CIR: %[[TRUE:.*]] = cir.const #true
@@ -218,7 +218,7 @@ A *deact_while_cond(int n) {
}
// CIR-LABEL: cir.func {{.*}} @_Z16deact_while_condi
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.isactive"]
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.while {
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
@@ -297,7 +297,7 @@ A *deact_switch(int kind) {
}
// CIR-LABEL: cir.func {{.*}} @_Z12deact_switchi
-// CIR: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.isactive"]
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.switch({{.*}}) {
// CIR: cir.case(equal, [#cir.int<1> : !s32i]) {
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
diff --git a/clang/test/CIR/CodeGen/new-delete.cpp b/clang/test/CIR/CodeGen/new-delete.cpp
index fa8ed0dfeb947..ffc8741fff528 100644
--- a/clang/test/CIR/CodeGen/new-delete.cpp
+++ b/clang/test/CIR/CodeGen/new-delete.cpp
@@ -13,8 +13,8 @@ A *a() {
}
// CIR: cir.func {{.*}} @_Z1av() -> !cir.ptr<!rec_A>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["__retval"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["__new_result"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR: %[[PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
@@ -88,8 +88,8 @@ A *b() {
}
// CIR: cir.func {{.*}} @_Z1bv() -> !cir.ptr<!rec_A>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["__retval"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["__new_result"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR: %[[PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
@@ -178,8 +178,8 @@ B *c() {
}
// CIR: cir.func {{.*}} @_Z1cv() -> !cir.ptr<!rec_B>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["__retval"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["__new_result"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[PTR:.*]] = cir.call @_ZN1BnwEm(%[[ALLOC_SIZE]]) : (!u64i) -> !cir.ptr<!void>
// CIR: cir.cleanup.scope {
@@ -257,13 +257,13 @@ C *test_new_delete_conditional(bool cond) {
}
// CIR-LABEL: @_Z27test_new_delete_conditionalb
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]]
// CIR: %[[TERN_RESULT:.*]] = cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["cond-cleanup.save"]
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["cond-cleanup.save"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["__new_result"]
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[NEW_PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]])
// CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]]
@@ -336,12 +336,12 @@ C *test_new_delete_conditional_with_placement(bool cond, int tag) {
}
// CIR-LABEL: @_Z42test_new_delete_conditional_with_placementbi
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[TERN_RESULT:.*]] = cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["cond-cleanup.save"]
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["cond-cleanup.save"]
-// CIR: %[[TAG_SAVE:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond-cleanup.save"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["__new_result"]
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[TAG_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[TAG_VAL:.*]] = cir.load{{.*}}
// CIR: %[[NEW_PTR:.*]] = cir.call @_Znwmi(%[[ONE]], %[[TAG_VAL]])
@@ -423,13 +423,13 @@ D *test_new_delete_conditional_with_size(bool cond) {
}
// CIR-LABEL: @_Z37test_new_delete_conditional_with_sizeb
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]]
// CIR: cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["cond-cleanup.save"]
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["cond-cleanup.save"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>, ["__new_result"]
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[NEW_PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]])
// CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]]
@@ -498,13 +498,13 @@ D *test_new_delete_conditional_array(bool cond, int n) {
}
// CIR-LABEL: @_Z33test_new_delete_conditional_arraybi
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]]
// CIR: cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["cond-cleanup.save"]
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["cond-cleanup.save"]
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>, ["__new_result"]
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[N:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_EXT:.*]] = cir.cast integral %[[N]] : !s32i -> !s64i
// CIR: %result, %overflow = cir.add.overflow %{{.*}}, %{{.*}} : !u64i -> !u64i
diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp
index 00e5379b0c013..f4dabcd970371 100644
--- a/clang/test/CIR/CodeGen/new.cpp
+++ b/clang/test/CIR/CodeGen/new.cpp
@@ -20,9 +20,9 @@ void test_basic_new() {
}
// CHECK: cir.func{{.*}} @_Z14test_basic_newv
-// CHECK: %[[PS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["ps", init]
-// CHECK: %[[PN_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["pn", init]
-// CHECK: %[[PD_ADDR:.*]] = cir.alloca !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>, ["pd", init]
+// CHECK: %[[PS_ADDR:.*]] = cir.alloca "ps" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CHECK: %[[PN_ADDR:.*]] = cir.alloca "pn" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[PD_ADDR:.*]] = cir.alloca "pd" {{.*}} init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8>
// CHECK: %[[NEW_S:.*]] = cir.call @_Znwm(%[[EIGHT]])
// CHECK: %[[NEW_S_PTR:.*]] = cir.cast bitcast %[[NEW_S]]
@@ -67,8 +67,8 @@ void test_new_with_init() {
}
// CHECK: cir.func{{.*}} @_Z18test_new_with_initv
-// CHECK: %[[PN_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["pn", init]
-// CHECK: %[[PD_ADDR:.*]] = cir.alloca !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>, ["pd", init]
+// CHECK: %[[PN_ADDR:.*]] = cir.alloca "pn" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[PD_ADDR:.*]] = cir.alloca "pd" {{.*}} init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
// CHECK: %[[FOUR:.*]] = cir.const #cir.int<4>
// CHECK: %[[NEW_INT:.*]] = cir.call @_Znwm(%[[FOUR]])
// CHECK: %[[NEW_INT_PTR:.*]] = cir.cast bitcast %[[NEW_INT]]
@@ -118,8 +118,8 @@ void test_new_with_ctor() {
}
// CHECK: cir.func{{.*}} @_Z18test_new_with_ctorv
-// CHECK: %[[PS2_ADDR:.*]] = cir.alloca !cir.ptr<!rec_S2>, !cir.ptr<!cir.ptr<!rec_S2>>, ["ps2", init]
-// CHECK: %[[PS2_2_ADDR:.*]] = cir.alloca !cir.ptr<!rec_S2>, !cir.ptr<!cir.ptr<!rec_S2>>, ["ps2_2", init]
+// CHECK: %[[PS2_ADDR:.*]] = cir.alloca "ps2" {{.*}} init !cir.ptr<!rec_S2> -> !cir.ptr<!cir.ptr<!rec_S2>>
+// CHECK: %[[PS2_2_ADDR:.*]] = cir.alloca "ps2_2" {{.*}} init !cir.ptr<!rec_S2> -> !cir.ptr<!cir.ptr<!rec_S2>>
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8>
// CHECK: %[[NEW_S2:.*]] = cir.call @_Znwm(%[[EIGHT]])
// CHECK: %[[NEW_S2_PTR:.*]] = cir.cast bitcast %[[NEW_S2]]
@@ -161,7 +161,7 @@ void test_new_with_complex_type() {
}
// CHECK: cir.func{{.*}} @_Z26test_new_with_complex_typev
-// CHECK: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!cir.complex<!cir.float>>, !cir.ptr<!cir.ptr<!cir.complex<!cir.float>>>, ["a", init]
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!cir.ptr<!cir.complex<!cir.float>>>
// CHECK: %[[COMPLEX_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK: %[[NEW_COMPLEX:.*]] = cir.call @_Znwm(%[[COMPLEX_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CHECK: %[[COMPLEX_PTR:.*]] = cir.cast bitcast %[[NEW_COMPLEX]] : !cir.ptr<!void> -> !cir.ptr<!cir.complex<!cir.float>>
@@ -189,7 +189,7 @@ void t_new_constant_size() {
}
// CHECK: cir.func{{.*}} @_Z19t_new_constant_sizev()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>, ["p", init] {alignment = 8 : i64}
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<128> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CHECK: %[[TYPED_PTR:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!cir.double>
@@ -217,7 +217,7 @@ void t_constant_size_nontrivial() {
}
// CHECK: cir.func{{.*}} @_Z26t_constant_size_nontrivialv()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["p", init] {alignment = 8 : i64}
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CHECK: %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<11> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
@@ -257,7 +257,7 @@ void t_constant_size_nontrivial2() {
}
// CHECK: cir.func{{.*}} @_Z27t_constant_size_nontrivial2v()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>, ["p", init] {alignment = 8 : i64}
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
// CHECK: %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
@@ -289,7 +289,7 @@ void t_align16_nontrivial() {
}
// CHECK: cir.func{{.*}} @_Z20t_align16_nontrivialv()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>, ["p", init] {alignment = 8 : i64}
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!rec_E> -> !cir.ptr<!cir.ptr<!rec_E>>
// CHECK: %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<2> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<48> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
@@ -328,7 +328,7 @@ void t_new_multidim_constant_size() {
}
// CHECK: cir.func{{.*}} @_Z28t_new_multidim_constant_sizev()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>, !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>>, ["p", init] {alignment = 8 : i64}
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>>
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<192> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CHECK: %[[TYPED_PTR:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>
@@ -734,7 +734,7 @@ void test_array_new_with_ctor_init() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z29test_array_new_with_ctor_initv
-// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_F>, !cir.ptr<!cir.ptr<!rec_F>>, ["p", init]
+// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_F> -> !cir.ptr<!cir.ptr<!rec_F>>
// CIR-BEFORE-LPP: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
// CIR-BEFORE-LPP: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[THREE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CIR-BEFORE-LPP: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_F>
@@ -747,7 +747,7 @@ void test_array_new_with_ctor_init() {
// CIR-BEFORE-LPP: cir.return
// CHECK: cir.func {{.*}} @_Z29test_array_new_with_ctor_initv
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_F>, !cir.ptr<!cir.ptr<!rec_F>>, ["p", init]
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_F> -> !cir.ptr<!cir.ptr<!rec_F>>
// CHECK: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[THREE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CHECK: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_F>
@@ -755,7 +755,7 @@ void test_array_new_with_ctor_init() {
// CHECK: %[[THREE_2:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[ARRAY_BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY_PTR]] : !cir.ptr<!cir.array<!rec_F x 3>> -> !cir.ptr<!rec_F>
// CHECK: %[[ARRAY_END:.*]] = cir.ptr_stride %[[ARRAY_BEGIN]], %[[THREE_2]] : (!cir.ptr<!rec_F>, !u64i) -> !cir.ptr<!rec_F>
-// CHECK: %[[IDX_ADDR:.*]] = cir.alloca !cir.ptr<!rec_F>, !cir.ptr<!cir.ptr<!rec_F>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK: %[[IDX_ADDR:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_F> -> !cir.ptr<!cir.ptr<!rec_F>>
// CHECK: cir.store %[[ARRAY_BEGIN]], %[[IDX_ADDR]] : !cir.ptr<!rec_F>, !cir.ptr<!cir.ptr<!rec_F>>
// CHECK: cir.do {
// CHECK: %[[CUR:.*]] = cir.load %[[IDX_ADDR]] : !cir.ptr<!cir.ptr<!rec_F>>, !cir.ptr<!rec_F>
@@ -1108,7 +1108,7 @@ void test_array_new_with_ctor_partial_init_list() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z42test_array_new_with_ctor_partial_init_listv
-// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>, ["p", init]
+// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
// CIR-BEFORE-LPP: %[[EIGHT:.*]] = cir.const #cir.int<8> : !u64i
// CIR-BEFORE-LPP: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[EIGHT]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CIR-BEFORE-LPP: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_G>
@@ -1129,7 +1129,7 @@ void test_array_new_with_ctor_partial_init_list() {
// CIR-BEFORE-LPP: cir.return
// CHECK: cir.func {{.*}} @_Z42test_array_new_with_ctor_partial_init_listv
-// CHECK: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>, ["p", init]
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[EIGHT]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CHECK: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_G>
@@ -1145,7 +1145,7 @@ void test_array_new_with_ctor_partial_init_list() {
// CHECK: %[[SIX:.*]] = cir.const #cir.int<6> : !u64i
// CHECK: %[[ARRAY_BEGIN:.*]] = cir.cast array_to_ptrdecay %[[TAIL_ARRAY]] : !cir.ptr<!cir.array<!rec_G x 6>> -> !cir.ptr<!rec_G>
// CHECK: %[[ARRAY_END:.*]] = cir.ptr_stride %[[ARRAY_BEGIN]], %[[SIX]] : (!cir.ptr<!rec_G>, !u64i) -> !cir.ptr<!rec_G>
-// CHECK: %[[IDX_ADDR:.*]] = cir.alloca !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK: %[[IDX_ADDR:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
// CHECK: cir.store %[[ARRAY_BEGIN]], %[[IDX_ADDR]] : !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>
// CHECK: cir.do {
// CHECK: %[[CUR:.*]] = cir.load %[[IDX_ADDR]] : !cir.ptr<!cir.ptr<!rec_G>>, !cir.ptr<!rec_G>
diff --git a/clang/test/CIR/CodeGen/no-odr-use.cpp b/clang/test/CIR/CodeGen/no-odr-use.cpp
index 4e80f523e1320..23793dcca0433 100644
--- a/clang/test/CIR/CodeGen/no-odr-use.cpp
+++ b/clang/test/CIR/CodeGen/no-odr-use.cpp
@@ -88,7 +88,7 @@ int f(int i) {
// With CIR, f1() is emitted after the lambda.
// CIR-LABEL: cir.func {{.*}} @_Z1fi(
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["a", init, const]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init const !rec_A -> !cir.ptr<!rec_A>
// CIR: %[[A_INIT:.*]] = cir.get_global @[[F_A]] : !cir.ptr<!rec_A>
// CIR: cir.copy %[[A_INIT]] to %[[A_ADDR]]
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
diff --git a/clang/test/CIR/CodeGen/noexcept.cpp b/clang/test/CIR/CodeGen/noexcept.cpp
index 9336b8181f869..180e1bc350858 100644
--- a/clang/test/CIR/CodeGen/noexcept.cpp
+++ b/clang/test/CIR/CodeGen/noexcept.cpp
@@ -15,9 +15,9 @@ void no_except() {
bool c = noexcept(function_no_except());
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.store {{.*}} %[[CONST_TRUE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CONST_FALSE:.*]] = cir.const #false
diff --git a/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp b/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp
index df8186fc1f6ff..bb2613e1c3667 100644
--- a/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp
+++ b/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp
@@ -16,8 +16,8 @@ extern "C" void use() {
int g = getStruct(0).member;
// CIR-LABEL: @use()
- // CIR: %[[G_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["g", init]
- // CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca !rec_Struct, !cir.ptr<!rec_Struct>
+ // CIR: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca {{.*}} !rec_Struct -> !cir.ptr<!rec_Struct>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[GET_STRUCT_CALL:.*]] = cir.call @getStruct(%[[ZERO]])
// CIR: cir.store{{.*}} %[[GET_STRUCT_CALL]], %[[TEMP_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/non-type-template-param.cpp b/clang/test/CIR/CodeGen/non-type-template-param.cpp
index 0fa46d2ea0db6..0510c795f6da6 100644
--- a/clang/test/CIR/CodeGen/non-type-template-param.cpp
+++ b/clang/test/CIR/CodeGen/non-type-template-param.cpp
@@ -10,7 +10,7 @@ void template_foo() {
int a = N + 5;
}
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<5> : !s32i
// CIR: %[[ADD:.*]] = cir.add nsw %[[CONST_1]], %[[CONST_2]] : !s32i
diff --git a/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp b/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp
index b3f7709f7b9b8..586bf0a7d3909 100644
--- a/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp
+++ b/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp
@@ -62,10 +62,10 @@ Trivial t_init{1,2.2, &Other::x};
extern "C" void local() {
// CIR-LABEL: @local(
// LLVM-LABEL: @local(
- // CIR: cir.alloca !rec_WithMemPtr, !cir.ptr<!rec_WithMemPtr>, ["localMpt"] {alignment = 8 : i64}
- // CIR: cir.alloca !rec_Trivial, !cir.ptr<!rec_Trivial>, ["localT"] {alignment = 8 : i64}
- // CIR: %[[MPT_INIT:.*]] = cir.alloca !rec_WithMemPtr, !cir.ptr<!rec_WithMemPtr>, ["localMpt_init", init] {alignment = 8 : i64}
- // CIR: %[[T_INIT:.*]] = cir.alloca !rec_Trivial, !cir.ptr<!rec_Trivial>, ["localT_init", init] {alignment = 8 : i64}
+ // CIR: cir.alloca "localMpt" align(8) !rec_WithMemPtr -> !cir.ptr<!rec_WithMemPtr>
+ // CIR: cir.alloca "localT" align(8) !rec_Trivial -> !cir.ptr<!rec_Trivial>
+ // CIR: %[[MPT_INIT:.*]] = cir.alloca "localMpt_init" align(8) init !rec_WithMemPtr -> !cir.ptr<!rec_WithMemPtr>
+ // CIR: %[[T_INIT:.*]] = cir.alloca "localT_init" align(8) init !rec_Trivial -> !cir.ptr<!rec_Trivial>
// LLVM: alloca %struct.WithMemPtr
// LLVM: alloca %struct.Trivial
diff --git a/clang/test/CIR/CodeGen/nrvo.cpp b/clang/test/CIR/CodeGen/nrvo.cpp
index 08aad0723d331..1ad1aa811618d 100644
--- a/clang/test/CIR/CodeGen/nrvo.cpp
+++ b/clang/test/CIR/CodeGen/nrvo.cpp
@@ -23,14 +23,14 @@ struct S f1() {
}
// CIR: cir.func{{.*}} @_Z2f1v() -> !rec_S
-// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval", init]
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR-NEXT: cir.call @_ZN1SC1Ev(%[[RETVAL]]) : (!cir.ptr<!rec_S> {{.*}}) -> ()
// CIR-NEXT: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!rec_S>, !rec_S
// CIR-NEXT: cir.return %[[RET]]
// CIR-NOELIDE: cir.func{{.*}} @_Z2f1v() -> !rec_S
-// CIR-NOELIDE-NEXT: %[[RETVAL:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["__retval"]
-// CIR-NOELIDE-NEXT: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// CIR-NOELIDE-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR-NOELIDE-NEXT: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR-NOELIDE-NEXT: cir.call @_ZN1SC1Ev(%[[S]]) : (!cir.ptr<!rec_S> {{.*}}) -> ()
// CIR-NOELIDE-NEXT: cir.copy %[[S]] to %[[RETVAL]] : !cir.ptr<!rec_S>
// CIR-NOELIDE-NEXT: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!rec_S>, !rec_S
@@ -65,8 +65,8 @@ NonTrivial test_nrvo() {
// TODO(cir): Handle normal cleanup properly.
// CIR: cir.func {{.*}} @_Z9test_nrvov()
-// CIR: %[[RESULT:.*]] = cir.alloca !rec_NonTrivial, !cir.ptr<!rec_NonTrivial>, ["__retval"]
-// CIR: %[[NRVO_FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["nrvo"]
+// CIR: %[[RESULT:.*]] = cir.alloca "__retval" {{.*}} !rec_NonTrivial -> !cir.ptr<!rec_NonTrivial>
+// CIR: %[[NRVO_FLAG:.*]] = cir.alloca "nrvo" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store{{.*}} %[[FALSE]], %[[NRVO_FLAG]]
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/nullptr-init.cpp b/clang/test/CIR/CodeGen/nullptr-init.cpp
index 091269d09c985..cd764ec5e3ea9 100644
--- a/clang/test/CIR/CodeGen/nullptr-init.cpp
+++ b/clang/test/CIR/CodeGen/nullptr-init.cpp
@@ -12,9 +12,9 @@ void t1() {
}
// CIR: cir.func{{.*}} @_Z2t1v()
-// CIR-NEXT: %[[P1:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p1", init] {alignment = 8 : i64}
-// CIR-NEXT: %[[P2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p2", init] {alignment = 8 : i64}
-// CIR-NEXT: %[[P3:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p3", init] {alignment = 8 : i64}
+// CIR-NEXT: %[[P1:.*]] = cir.alloca "p1" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR-NEXT: %[[P2:.*]] = cir.alloca "p2" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR-NEXT: %[[P3:.*]] = cir.alloca "p3" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[NULLPTR1:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[NULLPTR1]], %[[P1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[NULLPTR2:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/opaque.c b/clang/test/CIR/CodeGen/opaque.c
index 73f6402e8a484..745fed1d77abc 100644
--- a/clang/test/CIR/CodeGen/opaque.c
+++ b/clang/test/CIR/CodeGen/opaque.c
@@ -11,9 +11,9 @@ void foo2() {
float _Complex c = a ?: b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// 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
diff --git a/clang/test/CIR/CodeGen/opaque.cpp b/clang/test/CIR/CodeGen/opaque.cpp
index fc4af01892ef1..8a76b15428e0c 100644
--- a/clang/test/CIR/CodeGen/opaque.cpp
+++ b/clang/test/CIR/CodeGen/opaque.cpp
@@ -10,8 +10,8 @@ void foo() {
int b = 1 ?: a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
@@ -29,9 +29,9 @@ void foo2() {
float _Complex c = a ?: b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// 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
@@ -107,9 +107,9 @@ void foo3() {
int c = a ?: b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
// 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: %[[RESULT:.*]] = cir.ternary(%[[A_BOOL]], true {
@@ -162,8 +162,8 @@ void test_gnu_binary_lvalue_assign() {
}
// CIR-LABEL: cir.func{{.*}} @_Z29test_gnu_binary_lvalue_assignv(
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[A_VAL:.*]] = cir.load{{.*}} %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[A_BOOL:.*]] = cir.cast int_to_bool %[[A_VAL]] : !s32i -> !cir.bool
// CIR: %[[TERNARY_PTR:.*]] = cir.ternary(%[[A_BOOL]], true {
@@ -210,8 +210,8 @@ void test_gnu_binary_lvalue_compound() {
}
// CIR-LABEL: cir.func{{.*}} @_Z31test_gnu_binary_lvalue_compoundv(
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[A_VAL:.*]] = cir.load{{.*}} %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[A_BOOL:.*]] = cir.cast int_to_bool %[[A_VAL]] : !s32i -> !cir.bool
// CIR: %[[LVAL_PTR:.*]] = cir.ternary(%[[A_BOOL]], true {
@@ -265,10 +265,10 @@ void test_gnu_binary_lvalue_ptr() {
}
// CIR-LABEL: cir.func{{.*}} @_Z26test_gnu_binary_lvalue_ptrv(
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[Y:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init]
-// CIR: %[[P:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p", init]
-// CIR: %[[Q:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["q", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[Q:.*]] = cir.alloca "q" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[P_VAL:.*]] = cir.load{{.*}} %[[P]]
// CIR: %[[P_BOOL:.*]] = cir.cast ptr_to_bool %[[P_VAL]]
// CIR: %[[PTR_RESULT:.*]] = cir.ternary(%[[P_BOOL]], true {
diff --git a/clang/test/CIR/CodeGen/openmp_default_simd_align.c b/clang/test/CIR/CodeGen/openmp_default_simd_align.c
index 8b4e25d8d09d9..18644eb0e4fcd 100644
--- a/clang/test/CIR/CodeGen/openmp_default_simd_align.c
+++ b/clang/test/CIR/CodeGen/openmp_default_simd_align.c
@@ -14,7 +14,7 @@ int f0(void) {
return __builtin_omp_required_simd_align(struct s0);
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_16:.*]] = cir.const #cir.int<16> : !s32i
// CIR: cir.store %[[CONST_16]], %[[RET_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_RET:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/pack-indexing.cpp b/clang/test/CIR/CodeGen/pack-indexing.cpp
index 37ecb1f10bf1d..6925d029c8d69 100644
--- a/clang/test/CIR/CodeGen/pack-indexing.cpp
+++ b/clang/test/CIR/CodeGen/pack-indexing.cpp
@@ -7,10 +7,10 @@
auto pack_indexing(auto... p) { return p...[0]; }
-// CIR: %[[P_0:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["p", init]
-// CIR: %[[P_1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["p", init]
-// CIR: %[[P_2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["p", init]
-// CIR: %[[RET_VAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[P_0:.*]] = cir.alloca "p" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[P_1:.*]] = cir.alloca "p" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[P_2:.*]] = cir.alloca "p" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[RESULT:.*]] = cir.load{{.*}} %[[P_0]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store %[[RESULT]], %[[RET_VAL]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load %[[RET_VAL]] : !cir.ptr<!s32i>, !s32i
@@ -33,7 +33,7 @@ auto pack_indexing(auto... p) { return p...[0]; }
int pack_indexing_scalar() { return pack_indexing(1, 2, 3); }
-// CIR: %[[RET_VAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[RESULT:.*]] = cir.call @_Z13pack_indexingIJiiiEEDaDpT_({{.*}}, {{.*}}, {{.*}}) : (!s32i {llvm.noundef}, !s32i {llvm.noundef}, !s32i {llvm.noundef}) -> (!s32i {llvm.noundef})
// CIR: cir.store %[[RESULT]], %[[RET_VAL]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load %[[RET_VAL]] : !cir.ptr<!s32i>, !s32i
@@ -54,9 +54,9 @@ float _Complex pack_indexing_complex() {
}
// CIR: cir.func {{.*}} @_Z21pack_indexing_complexv()
-// CIR: %[[RET_VAL:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["__retval"]
-// CIR: %[[COMPLEX_0:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["coerce"]
-// CIR: %[[COMPLEX_1:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["coerce"]
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[COMPLEX_0:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[COMPLEX_1:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[CONST_COMPLEX_0:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: %[[CONST_COMPLEX_1:.*]] = cir.const #cir.const_complex<#cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store {{.*}} %[[CONST_COMPLEX_0]], %[[COMPLEX_0]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
diff --git a/clang/test/CIR/CodeGen/paren-init-list-eh.cpp b/clang/test/CIR/CodeGen/paren-init-list-eh.cpp
index a23e445155785..5b123f62a7c3e 100644
--- a/clang/test/CIR/CodeGen/paren-init-list-eh.cpp
+++ b/clang/test/CIR/CodeGen/paren-init-list-eh.cpp
@@ -22,7 +22,7 @@ void test_init_list_with_dtor() {
}
// CIR: cir.func {{.*}} @_Z24test_init_list_with_dtorv
-// CIR: %[[O:.*]] = cir.alloca !rec_Outer, !cir.ptr<!rec_Outer>, ["o", init]
+// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} init !rec_Outer -> !cir.ptr<!rec_Outer>
// CIR: %[[S1:.*]] = cir.get_member %[[O]][0] {name = "s1"} : !cir.ptr<!rec_Outer> -> !cir.ptr<!rec_Struk>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR: cir.call @_ZN5StrukC1Ei(%[[S1]], %[[ONE]])
diff --git a/clang/test/CIR/CodeGen/paren-init-list.cpp b/clang/test/CIR/CodeGen/paren-init-list.cpp
index ad3915cdcb70f..755978a120d52 100644
--- a/clang/test/CIR/CodeGen/paren-init-list.cpp
+++ b/clang/test/CIR/CodeGen/paren-init-list.cpp
@@ -15,7 +15,7 @@ void cxx_paren_list_init_expr() { CompleteS a(1, 'a'); }
// CIR-DAG: cir.global "private" constant cir_private @[[PAREN_A:.*]] = #cir.const_record<{#cir.int<1> : !s32i, #cir.int<97> : !s8i}> : !rec_CompleteS
// LLVM-DAG: @[[PAREN_A:.*]] = private constant %struct.CompleteS { i32 1, i8 97 }
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: %[[CONST:.*]] = cir.get_global @[[PAREN_A]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]]
@@ -40,7 +40,7 @@ void test_init_list_with_dtor() {
}
// CIR: cir.func {{.*}} @_Z24test_init_list_with_dtorv
-// CIR: %[[O:.*]] = cir.alloca !rec_Outer, !cir.ptr<!rec_Outer>, ["o", init]
+// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} init !rec_Outer -> !cir.ptr<!rec_Outer>
// CIR: %[[H:.*]] = cir.get_member %[[O]][0] {name = "h"} : !cir.ptr<!rec_Outer> -> !cir.ptr<!rec_HasDtor>
// CIR: %[[VAL:.*]] = cir.get_member %[[H]][0] {name = "val"} : !cir.ptr<!rec_HasDtor> -> !cir.ptr<!s32i>
// CIR: %[[CONST:.*]] = cir.const #cir.int<1>
diff --git a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
index de457472208b9..1924a515d3b19 100644
--- a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
+++ b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
@@ -158,7 +158,7 @@ constexpr int arr5[2](2);
// LLVM-NEXT: [[TMP_0:%.*]] = load {{.*}}, ptr [[RETVAL]], align 8
// LLVM-NEXT: ret {{.*}}[[TMP_0]]
// CIR-LABEL: cir.func {{.*}}@_Z4foo1v()
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca ![[STRUCT_A]], !cir.ptr<![[STRUCT_A]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_A1:.*]] = cir.get_global @_ZL2a1 : !cir.ptr<![[STRUCT_A]]>
// CIR: cir.copy %[[GET_A1]] to %[[A_ALLOCA]] : !cir.ptr<![[STRUCT_A]]>
A foo1() {
@@ -168,7 +168,7 @@ A foo1() {
// LLVM: define dso_local {{.*}}@{{.*foo2.*}}
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}, ptr {{.*}}[[B1]], i64 24, i1 false)
// CIR: cir.func {{.*}}@_Z4foo2v()
-// CIR: %[[B_ALLOCA:.*]] = cir.alloca ![[STRUCT_B]], !cir.ptr<![[STRUCT_B]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[B_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_B]] -> !cir.ptr<![[STRUCT_B]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2b1 : !cir.ptr<![[STRUCT_B]]>
// CIR: cir.copy %[[GET_GLOB]] to %[[B_ALLOCA]] : !cir.ptr<![[STRUCT_B]]>
B foo2() {
@@ -178,7 +178,7 @@ B foo2() {
// LLVM: define dso_local {{.*}}@{{.*foo3.*}}
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}, ptr {{.*}}[[C1]], i64 48, i1 false)
// CIR: cir.func {{.*}}@_Z4foo3v()
-// CIR: %[[C_ALLOCA:.*]] = cir.alloca ![[STRUCT_C]], !cir.ptr<![[STRUCT_C]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[C_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_C]] -> !cir.ptr<![[STRUCT_C]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2c1
// CIR: %[[GLOB_CAST:.*]] = cir.cast bitcast %[[GET_GLOB]] : !cir.ptr<!{{.*}}> -> !cir.ptr<![[STRUCT_C]]>
// CIR: cir.copy %[[GLOB_CAST]] to %[[C_ALLOCA]] : !cir.ptr<![[STRUCT_C]]>
@@ -208,9 +208,9 @@ C foo3() {
// LLVM-NEXT: store i32 2, ptr [[C]]
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_Z4foo4v()
-// CIR: %[[C2_ALLOCA:.*]] = cir.alloca ![[STRUCT_C]], !cir.ptr<![[STRUCT_C]]>, ["c2", init]
-// CIR: %[[B_TMP:.*]] = cir.alloca ![[STRUCT_B]], !cir.ptr<![[STRUCT_B]]>, ["ref.tmp0"]
-// CIR: %[[A_TMP:.*]] = cir.alloca ![[STRUCT_A]], !cir.ptr<![[STRUCT_A]]>, ["ref.tmp1"]
+// CIR: %[[C2_ALLOCA:.*]] = cir.alloca "c2" {{.*}} init ![[STRUCT_C]] -> !cir.ptr<![[STRUCT_C]]>
+// CIR: %[[B_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[STRUCT_B]] -> !cir.ptr<![[STRUCT_B]]>
+// CIR: %[[A_TMP:.*]] = cir.alloca "ref.tmp1" {{.*}} ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[C_BASE:.*]] = cir.base_class_addr %[[C2_ALLOCA]] : !cir.ptr<![[STRUCT_C]]> nonnull [0] -> !cir.ptr<![[STRUCT_B]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[B_TMP]][0] {name = "a"} : !cir.ptr<![[STRUCT_B]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[GET_A]][0] {name = "i"} : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!s8i>
@@ -243,7 +243,7 @@ void foo4() {
// LLVM: [[RETVAL:%.*]] = alloca [[UNION_U]]
// LLVM-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}[[RETVAL]], ptr {{.*}}[[U1]], i64 16, i1 false)
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo5v()
-// CIR: %[[RET:.*]] = cir.alloca ![[UNION_U]], !cir.ptr<![[UNION_U]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[RET:.*]] = cir.alloca "__retval" align(8) ![[UNION_U]] -> !cir.ptr<![[UNION_U]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2u1 : !cir.ptr<!{{.*}}>
// CIR: %[[GLOB_TO_U:.*]] = cir.cast bitcast %[[GET_GLOB]] : !cir.ptr<!{{.*}}> -> !cir.ptr<![[UNION_U]]>
// CIR: cir.copy %[[GLOB_TO_U]] to %[[RET]] : !cir.ptr<![[UNION_U]]>
@@ -257,8 +257,8 @@ U foo5() {
// LLVM-DAG: [[A:%.*]] = alloca [[STRUCT_A]]
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}[[RETVAL]], ptr {{.*}}[[A]], i64 16, i1 false)
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo61A(
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca ![[STRUCT_A]], !cir.ptr<![[STRUCT_A]]>, ["a", init] {alignment = 8 : i64}
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca ![[UNION_U]], !cir.ptr<![[UNION_U]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(8) init ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[UNION_U]] -> !cir.ptr<![[UNION_U]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[RET_ALLOCA:.*]][1] {name = "a"} : !cir.ptr<![[UNION_U]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: cir.copy %[[A_ALLOCA]] to %[[GET_A:.*]] : !cir.ptr<![[STRUCT_A]]>
U foo6(A a) {
@@ -284,7 +284,7 @@ U foo6(A a) {
// LLVM-NEXT: store double 1.110000e+02, ptr [[J4]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL; cir.func no_inline dso_local @_Z4foo7v()
-// CIR: %[[D_ALLOCA:.*]] = cir.alloca ![[STRUCT_D]], !cir.ptr<![[STRUCT_D]]>, ["d", init] {alignment = 8 : i64}
+// CIR: %[[D_ALLOCA:.*]] = cir.alloca "d" align(8) init ![[STRUCT_D]] -> !cir.ptr<![[STRUCT_D]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[D_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_D]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[GET_A]][0] {name = "i"} : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!s8i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s8i
@@ -316,7 +316,7 @@ void foo7() {
// LLVM: dso_local {{.*}}@{{.*foo8.*}}(
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}, ptr {{.*}}[[D1]], i64 56, i1 false)
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo8v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca ![[STRUCT_D]], !cir.ptr<![[STRUCT_D]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_D]] -> !cir.ptr<![[STRUCT_D]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2d1 :
// CIR: %[[GLOB_CAST:.*]] = cir.cast bitcast %[[GET_GLOB]] : !cir.ptr<!{{.*}}> -> !cir.ptr<![[STRUCT_D]]>
// CIR: cir.copy %[[GLOB_CAST]] to %[[RET_ALLOCA]] : !cir.ptr<![[STRUCT_D]]>
@@ -338,7 +338,7 @@ D foo8() {
// LLVM-NEXT: store double 2.000000e+00, ptr [[J2]], align 8
// LLVM-NEXT: [[C:%.*]] = getelementptr {{.*}}[[STRUCT_D]], ptr [[D]], i32 0, i32 3
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo9v()
-// CIR: %[[D_ALLOCA:.*]] = cir.alloca ![[STRUCT_D]], !cir.ptr<![[STRUCT_D]]>, ["d", init] {alignment = 8 : i64}
+// CIR: %[[D_ALLOCA:.*]] = cir.alloca "d" align(8) init ![[STRUCT_D]] -> !cir.ptr<![[STRUCT_D]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[D_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_D]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[GET_A]][0] {name = "i"} : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!s8i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s8i
@@ -364,7 +364,7 @@ void foo9() {
// LLVM: define dso_local noundef ptr @{{.*foo10.*}}()
// FIXME: CIR lowering has an extra load here.
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo10v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL4arr1 : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[GLOB_DECAY:.*]] = cir.cast array_to_ptrdecay %[[GET_GLOB]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: cir.store %[[GLOB_DECAY]], %[[RET_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -390,10 +390,10 @@ const int* foo10() {
// LLVM-NEXT: br i1 [[ARRINIT_DONE]], label
// LLVM: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo11ii
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
-// CIR: %[[B_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
-// CIR: %[[ARR2_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 4>, !cir.ptr<!cir.array<!s32i x 4>>, ["arr2", init] {alignment = 16 : i64}
-// CIR: %[[ARR_ITR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arrayinit.temp", init] {alignment = 8 : i64}
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ALLOCA:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR2_ALLOCA:.*]] = cir.alloca "arr2" align(16) init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
+// CIR: %[[ARR_ITR:.*]] = cir.alloca "arrayinit.temp" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[ARR2_DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARR2_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 4>> -> !cir.ptr<!s32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %[[A_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store align(4) %[[A_LOAD]], %[[ARR2_DECAY]] : !s32i, !cir.ptr<!s32i>
@@ -436,9 +436,9 @@ void foo11(int a, int b) {
// LLVM-NEXT: store i32 [[TMP_1]], ptr [[ARRINIT_ELEMENT]], align 4
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo12ii
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
-// CIR: %[[B_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
-// CIR: %[[ARR3_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["arr3", init] {alignment = 4 : i64}
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ALLOCA:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR3_ALLOCA:.*]] = cir.alloca "arr3" align(4) init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARR3_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %[[A_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store align(4) %[[A_LOAD]], %[[ARR_DECAY]] : !s32i, !cir.ptr<!s32i>
@@ -456,7 +456,7 @@ void foo12(int a, int b) {
// LLVM-NEXT: [[TMP_0:%.*]] = load {{.*}}, ptr [[RETVAL]], align 8
// LLVM-NEXT: ret {{.*}}[[TMP_0]]
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo13v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca ![[STRUCT_A]], !cir.ptr<![[STRUCT_A]]>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
// CIR; %[[GET_GLOB:.*]] = cir.get_global @_ZL2a2 : !cir.ptr<![[STRUCT_A]]>
// CIR; cir.copy %[[GET_GLOB]] to %[[RET_ALLOCA]] : !cir.ptr<![[STRUCT_A]]>
A foo13() {
@@ -466,7 +466,7 @@ A foo13() {
// LLVM: define dso_local noundef ptr @{{.*foo14.*}}()
// LLVM: ret ptr
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo14v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL4arr4 : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[GLOB_DECAY]] = cir.cast array_to_ptrdecay %[[GET_GLOB]] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!s32i>
// CIR: cir.store %[[GLOB_DECAY]], %[[RET_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -477,7 +477,7 @@ const int* foo14() {
// LLVM: define dso_local noundef ptr @{{.*foo15.*}}()
// LLVM: ret ptr
// CIR-LABEL: cir.func {{.*}}@_Z5foo15v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["__retval"] {alignment = 8 : i64}
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL4arr5 : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[GLOB_DECAY:.*]] = cir.cast array_to_ptrdecay %[[GET_GLOB]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: cir.store %[[GLOB_DECAY]], %[[RET_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -492,8 +492,8 @@ const int* foo15() {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[ARR_6]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo16v()
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 1>, !cir.ptr<!cir.array<!s32i x 1>>, ["ref.tmp0"] {alignment = 4 : i64}
-// CIR: %[[ARR6_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>, ["arr6", init, const] {alignment = 8 : i64}
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) !cir.array<!s32i x 1> -> !cir.ptr<!cir.array<!s32i x 1>>
+// CIR: %[[ARR6_ALLOCA:.*]] = cir.alloca "arr6" align(8) init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TEMP_DECAY:.*]] = cir.cast array_to_ptrdecay %[[TEMP_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!s32i>
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR: cir.store align(4) %[[THREE]], %[[TEMP_DECAY]] : !s32i, !cir.ptr<!s32i>
@@ -515,9 +515,9 @@ void foo16() {
// LLVM: store ptr [[REF_TMP]], ptr [[ARR_7]], align 8
// LLVM: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo17v()
-// CIR: %[[ARR_TEMP:.*]] = cir.alloca !cir.array<!s32i x 2>, !cir.ptr<!cir.array<!s32i x 2>>, ["ref.tmp0"] {alignment = 4 : i64}
-// CIR: %[[ARR7_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 2>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>, ["arr7", init, const] {alignment = 8 : i64}
-// CIR: %[[ITR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arrayinit.temp", init] {alignment = 8 : i64}
+// CIR: %[[ARR_TEMP:.*]] = cir.alloca "ref.tmp0" align(4) !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[ARR7_ALLOCA:.*]] = cir.alloca "arr7" align(8) init const !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>
+// CIR: %[[ITR:.*]] = cir.alloca "arrayinit.temp" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[TEMP_LOAD:.*]] = cir.cast array_to_ptrdecay %[[ARR_TEMP]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store align(4) %[[FOUR]], %[[TEMP_LOAD]] : !s32i, !cir.ptr<!s32i>
@@ -552,7 +552,7 @@ void foo17() {
// LLVM-NEXT: store ptr [[STR]], ptr [[FN]], align 8
// LLVM: ret void
// CIR: cir.func {{.*}}@_Z5foo18v()
-// CIR: %[[E_ALLOCA:.*]] = cir.alloca ![[STRUCT_E]], !cir.ptr<![[STRUCT_E]]>, ["e", init]
+// CIR: %[[E_ALLOCA:.*]] = cir.alloca "e" {{.*}} init ![[STRUCT_E]] -> !cir.ptr<![[STRUCT_E]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[E_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_E]]> -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[ONE]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -571,7 +571,7 @@ void foo18() {
// LLVM-NEXT: call void @{{.*F.*}}(ptr noundef nonnull align 1 dereferenceable(1) [[F]], i32 noundef 1)
// LLVM: ret void
// CIR: cir.func no_inline dso_local @_Z5foo19v() attributes {{{.*}}nothrow} {
-// CIR: %[[G_ALLOCA:.*]] = cir.alloca ![[STRUCT_G]], !cir.ptr<![[STRUCT_G]]>, ["g", init]
+// CIR: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init ![[STRUCT_G]] -> !cir.ptr<![[STRUCT_G]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[G_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_G]]> -> !cir.ptr<!s32i>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: cir.store{{.*}} %[[TWO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -600,8 +600,8 @@ namespace gh61145 {
// LLVM: call void @_ZN7gh611453VecD1Ev(ptr {{.*}}[[V]])
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh611455make1ILi0EEEvv()
- // CIR: %[[V_ALLOCA:.*]] = cir.alloca ![[STRUCT_VEC]], !cir.ptr<![[STRUCT_VEC]]>, ["v", init] {alignment = 1 : i64}
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_S1]], !cir.ptr<![[STRUCT_S1]]>, ["agg.tmp.ensured"]
+ // CIR: %[[V_ALLOCA:.*]] = cir.alloca "v" align(1) init ![[STRUCT_VEC]] -> !cir.ptr<![[STRUCT_VEC]]>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_S1]] -> !cir.ptr<![[STRUCT_S1]]>
// CIR: cir.call @_ZN7gh611453VecC1Ev(%[[V_ALLOCA]])
// CIR: %[[S1_TO_VEC:.*]] = cir.cast bitcast %[[TMP_ALLOCA]] : !cir.ptr<![[STRUCT_S1]]> -> !cir.ptr<![[STRUCT_VEC]]>
// CIR: cir.call @_ZN7gh611453VecC1EOS0_(%[[S1_TO_VEC]], %[[V_ALLOCA]])
@@ -629,8 +629,8 @@ namespace gh61145 {
// LLVM: call void @_ZN7gh611453VecD1Ev(ptr {{.*}}[[V]])
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh611455make2ILi0EEEvv()
- // CIR: %[[V_ALLOCA:.*]] = cir.alloca ![[STRUCT_VEC]], !cir.ptr<![[STRUCT_VEC]]>, ["v", init] {alignment = 1 : i64}
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_S2]], !cir.ptr<![[STRUCT_S2]]>, ["agg.tmp.ensured"]
+ // CIR: %[[V_ALLOCA:.*]] = cir.alloca "v" align(1) init ![[STRUCT_VEC]] -> !cir.ptr<![[STRUCT_VEC]]>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_S2]] -> !cir.ptr<![[STRUCT_S2]]>
// CIR: cir.call @_ZN7gh611453VecC1Ev(%[[V_ALLOCA]])
// CIR: %[[S2_TO_VEC:.*]] = cir.cast bitcast %[[TMP_ALLOCA]] : !cir.ptr<![[STRUCT_S2]]> -> !cir.ptr<![[STRUCT_VEC]]>
// CIR: cir.call @_ZN7gh611453VecC1EOS0_(%[[S2_TO_VEC]], %[[V_ALLOCA]])
@@ -658,7 +658,7 @@ namespace gh62266 {
// LLVM-NEXT: store i32 2, ptr [[J]], align 4
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh622665foo20Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_H]], !cir.ptr<![[STRUCT_H]]>, ["h", init]
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "h" {{.*}} init ![[STRUCT_H]] -> !cir.ptr<![[STRUCT_H]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "i"} : !cir.ptr<![[STRUCT_H]]> -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -684,8 +684,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[R]], align 8
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh615675foo21Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_I]], !cir.ptr<![[STRUCT_I]]>, ["agg.tmp.ensured"]
- // CIR: %[[INT_TMP:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp0"]
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -708,8 +708,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[R]], align 8
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh615675foo22Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_I]], !cir.ptr<![[STRUCT_I]]>, ["agg.tmp.ensured"]
- // CIR: %[[INT_TMP:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp0"]
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -730,8 +730,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[I_ADDR]], ptr [[R]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func no_inline dso_local @_ZN7gh615675foo23Ei(%arg0: !s32i {llvm.noundef}
- // CIR: %[[I_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_I]], !cir.ptr<![[STRUCT_I]]>, ["agg.tmp.ensured"]
+ // CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -751,8 +751,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[R]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh615675foo24Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca ![[STRUCT_I]], !cir.ptr<![[STRUCT_I]]>, ["agg.tmp.ensured"]
- // CIR: %[[INT_TMP:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp0"]
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA:.*]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -776,7 +776,7 @@ namespace gh68198 {
// LLVM-NEXT: store ptr [[CALL_PTR]], ptr [[ARR_8]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.{{.*}}@_ZN7gh681985foo25Ev()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arr8", init] {alignment = 8 : i64}
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr8" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_TO_ARR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
@@ -806,7 +806,7 @@ namespace gh68198 {
// LLVM-NEXT: store ptr [[CALL_PTR]], ptr [[ARR_10]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.{{.*}}@_ZN7gh681985foo26Ev()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["arr9", init] {alignment = 8 : i64}
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr9" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_TO_ARR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!s32i x 2>>
@@ -849,7 +849,7 @@ namespace gh68198 {
// LLVM-NEXT: store ptr [[CALL_PTR]], ptr [[ARR_10]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.{{.*}}@_ZN7gh681985foo27Ev()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["arr10", init] {alignment = 8 : i64}
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr10" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<32> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_TO_ARR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!s32i x 2>>
diff --git a/clang/test/CIR/CodeGen/partial-array-cleanup.cpp b/clang/test/CIR/CodeGen/partial-array-cleanup.cpp
index ce085ecc53be9..4dc6e6739dd4d 100644
--- a/clang/test/CIR/CodeGen/partial-array-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/partial-array-cleanup.cpp
@@ -16,7 +16,7 @@ void test_partial_array_cleanup() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z26test_partial_array_cleanupv()
-// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, ["s", init]
+// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
// CIR-BEFORE-LPP: cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> {
// CIR-BEFORE-LPP: ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -26,11 +26,11 @@ void test_partial_array_cleanup() {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z26test_partial_array_cleanupv()
-// CIR: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, ["s", init]
+// CIR: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
// CIR: %[[CONST4:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST4]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[BEGIN]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.cleanup.scope {
// CIR: cir.do {
@@ -165,12 +165,12 @@ void test_variable_size_partial_array_cleanup(int n) {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z40test_variable_size_partial_array_cleanupi
-// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BEFORE-LPP: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP: cir.stacksave
// CIR-BEFORE-LPP: cir.cleanup.scope {
-// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[N]] : !u64i, ["s", init]
+// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
// CIR-BEFORE-LPP: cir.array.ctor %[[VLA]], %[[N]] : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP: ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -190,19 +190,19 @@ void test_variable_size_partial_array_cleanup(int n) {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z40test_variable_size_partial_array_cleanupi
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR: %[[STACK:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK]], %[[SAVED_STACK]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[BEGIN:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[N]] : !u64i, ["s", init]
+// CIR: %[[BEGIN:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[N]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CIR: %[[IS_NONZERO:.*]] = cir.cmp ne %[[N]], %[[ZERO]] : !u64i
// CIR: cir.if %[[IS_NONZERO]] {
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[BEGIN]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.cleanup.scope {
// CIR: cir.do {
@@ -244,7 +244,7 @@ void test_variable_size_partial_array_cleanup(int n) {
// CIR: %[[LAST:.*]] = cir.ptr_stride %[[BEGIN]], %[[N]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR: %[[DTOR_NE:.*]] = cir.cmp ne %[[LAST]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR: cir.if %[[DTOR_NE]] {
-// CIR: %[[DTOR_ITER:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
+// CIR: %[[DTOR_ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[LAST]], %[[DTOR_ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[DTOR_CUR:.*]] = cir.load %[[DTOR_ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
@@ -438,8 +438,8 @@ void test_multi_dim_vla(int n, int m) {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z18test_multi_dim_vlaii
-// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR-BEFORE-LPP: %[[M_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["m", init]
+// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BEFORE-LPP: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BEFORE-LPP: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP: %[[M_VAL:.*]] = cir.load {{.*}} %[[M_ADDR]] : !cir.ptr<!s32i>, !s32i
@@ -447,7 +447,7 @@ void test_multi_dim_vla(int n, int m) {
// CIR-BEFORE-LPP: cir.stacksave
// CIR-BEFORE-LPP: cir.cleanup.scope {
// CIR-BEFORE-LPP: %[[NM:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
-// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[NM]] : !u64i, ["s", init]
+// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[NM]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
// CIR-BEFORE-LPP: cir.array.ctor %[[VLA]], {{.*}} : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP: ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -467,16 +467,16 @@ void test_multi_dim_vla(int n, int m) {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z18test_multi_dim_vlaii
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR: %[[M_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["m", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR: %[[M_VAL:.*]] = cir.load {{.*}} %[[M_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[M:.*]] = cir.cast integral %[[M_VAL]] : !s32i -> !u64i
// CIR: cir.cleanup.scope {
// CIR: %[[NM:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
-// CIR: %[[BEGIN:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, %[[NM]] : !u64i, ["s", init]
+// CIR: %[[BEGIN:.*]] = cir.alloca "s" {{.*}} init %[[NM]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev
// CIR: } cleanup eh {
// CIR: cir.call @_ZN1SD1Ev
@@ -552,12 +552,12 @@ void test_vla_of_constant_array(int n) {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z26test_vla_of_constant_arrayi
-// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BEFORE-LPP: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP: cir.stacksave
// CIR-BEFORE-LPP: cir.cleanup.scope {
-// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, %[[N]] : !u64i, ["s", init]
+// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
// CIR-BEFORE-LPP: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
// CIR-BEFORE-LPP: %[[TOTAL:.*]] = cir.mul nuw %[[N]], %[[FOUR]] : !u64i
// CIR-BEFORE-LPP: %[[ELEM_PTR:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
@@ -583,11 +583,11 @@ void test_vla_of_constant_array(int n) {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z26test_vla_of_constant_arrayi
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR: cir.cleanup.scope {
-// CIR: %[[VLA:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, %[[N]] : !u64i, ["s", init]
+// CIR: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[TOTAL:.*]] = cir.mul nuw %[[N]], %[[FOUR]] : !u64i
// CIR: %[[ELEM_PTR:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
@@ -664,8 +664,8 @@ void test_init_list_partial_array_cleanup() {
}
// CIR-LABEL: cir.func {{.*}} @_Z36test_init_list_partial_array_cleanupv()
-// CIR: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 4>, !cir.ptr<!cir.array<!rec_S x 4>>, ["arr", init]
-// CIR: %[[END_OF_INIT:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["arrayinit.endOfInit"]
+// CIR: %[[ARRAY:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
+// CIR: %[[END_OF_INIT:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR: cir.store {{.*}} %[[BEGIN]], %[[END_OF_INIT]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/pass-object-size.c b/clang/test/CIR/CodeGen/pass-object-size.c
index eaaeb77241bca..df9d26ed863a9 100644
--- a/clang/test/CIR/CodeGen/pass-object-size.c
+++ b/clang/test/CIR/CodeGen/pass-object-size.c
@@ -16,7 +16,7 @@ void test_constant() {
}
// CIR: cir.func {{.*}} @test_constant()
-// CIR: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>
+// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[CAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: cir.call @b(%[[CAST]], %[[SIZE]]) : (!cir.ptr<!void> {{.*}}, !u64i {{.*}}) -> ()
@@ -42,7 +42,7 @@ void test_vla(int n) {
}
// CIR: cir.func {{.*}} @test_vla
-// CIR: %[[VLA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %{{.*}} : !u64i, ["d"] {alignment = 16 : i64}
+// CIR: %[[VLA:.*]] = cir.alloca "d" align(16) %{{.*}} : !u64i, !s32i -> !cir.ptr<!s32i>
// CIR: %[[CAST1:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
// CIR: %[[SIZE1:.*]] = cir.objsize max nullunknown %[[CAST1]] : !cir.ptr<!void> -> !u64i
// CIR: cir.call @b(%[[CAST1]], %[[SIZE1]]) : (!cir.ptr<!void> {{.*}}, !u64i {{.*}}) -> ()
diff --git a/clang/test/CIR/CodeGen/placement-new.cpp b/clang/test/CIR/CodeGen/placement-new.cpp
index b181b93afaac9..1ea4aeeb53e3e 100644
--- a/clang/test/CIR/CodeGen/placement-new.cpp
+++ b/clang/test/CIR/CodeGen/placement-new.cpp
@@ -18,7 +18,7 @@ void test_reserved_placement_new(void *p) {
// CIR-LABEL: cir.func {{.*}} @_Z27test_reserved_placement_newPv(
// CIR-SAME: %[[ARG0:.*]]: !cir.ptr<!void>
-// CIR: %[[P:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CIR: cir.store %[[ARG0]], %[[P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[PTR:.*]] = cir.load{{.*}} %[[P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[PTR_A:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_A>
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 0e13a15219d65..40bbf81c2e56c 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
@@ -171,8 +171,8 @@ auto bitcast(int Foo::*x) {
// CIR-BEFORE: %{{.*}} = cir.cast bitcast %[[X]] : !cir.data_member<!s32i in !rec_Foo> -> !cir.data_member<!s32i in !rec_Bar>
// CIR-AFTER: cir.func {{.*}} @_Z7bitcastM3Fooi(%[[ARG0:.*]]: !s64i
-// CIR-AFTER: %[[X_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["x", init] {alignment = 8 : i64}
-// CIR-AFTER: %[[RET_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["__retval"] {alignment = 8 : i64}
+// CIR-AFTER: %[[X_ADDR:.*]] = cir.alloca "x" align(8) init !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) !s64i -> !cir.ptr<!s64i>
// CIR-AFTER: cir.store %[[ARG0]], %[[X_ADDR]]
// CIR-AFTER: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR-AFTER: cir.store %[[X]], %[[RET_ADDR]]
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
index 2100987462f8b..7f4ce69868166 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
@@ -53,14 +53,14 @@ int Point::*pt_member_nested_region = test1();
// Checks for test1()
// CIR-BEFORE: cir.func {{.*}} @_Z5test1v() -> !cir.data_member<!s32i in !rec_Point> attributes {{{.*}}nothrow} {
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca !cir.data_member<!s32i in !rec_Point>, !cir.ptr<!cir.data_member<!s32i in !rec_Point>>, ["__retval"]
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.data_member<!s32i in !rec_Point> -> !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
// CIR-BEFORE: %[[MEMBER:.*]] = cir.const #cir.data_member<1> : !cir.data_member<!s32i in !rec_Point>
// CIR-BEFORE: cir.store %[[MEMBER]], %[[RETVAL]] : !cir.data_member<!s32i in !rec_Point>, !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!cir.data_member<!s32i in !rec_Point>>, !cir.data_member<!s32i in !rec_Point>
// CIR-BEFORE: cir.return %[[RET]] : !cir.data_member<!s32i in !rec_Point>
// CIR-AFTER: cir.func {{.*}} @_Z5test1v() -> !s64i attributes {{{.*}}nothrow} {
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["__retval"]
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s64i -> !cir.ptr<!s64i>
// CIR-AFTER: %[[OFFSET:.*]] = cir.const #cir.int<4> : !s64i
// CIR-AFTER: cir.store %[[OFFSET]], %[[RETVAL]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!s64i>, !s64i
@@ -87,9 +87,9 @@ int test2(const Point &pt, int Point::*member) {
// CIR-BEFORE: cir.func {{.*}} @_Z5test2RK5PointMS_i(
// CIR-BEFORE-SAME: %[[PT_ARG:.*]]: !cir.ptr<!rec_Point>
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Point>
-// CIR-BEFORE: %[[PT_ADDR:.*]] = cir.alloca {{.*}} ["pt", init, const]
-// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca {{.*}} ["member", init]
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca {{.*}} ["__retval"]
+// CIR-BEFORE: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init const
+// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
// CIR-BEFORE: cir.store %[[PT_ARG]], %[[PT_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[PT:.*]] = cir.load %[[PT_ADDR]]
@@ -103,9 +103,9 @@ int test2(const Point &pt, int Point::*member) {
// CIR-AFTER: cir.func {{.*}} @_Z5test2RK5PointMS_i(
// CIR-AFTER-SAME: %[[PT_ARG:.*]]: !cir.ptr<!rec_Point>
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Point>, !cir.ptr<!cir.ptr<!rec_Point>>, ["pt", init, const]
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["member", init]
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init const !cir.ptr<!rec_Point> -> !cir.ptr<!cir.ptr<!rec_Point>>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-AFTER: cir.store %[[PT_ARG]], %[[PT_ADDR]] : !cir.ptr<!rec_Point>, !cir.ptr<!cir.ptr<!rec_Point>>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[PT:.*]] = cir.load %[[PT_ADDR]] : !cir.ptr<!cir.ptr<!rec_Point>>, !cir.ptr<!rec_Point>
@@ -150,9 +150,9 @@ int test3(const Point *pt, int Point::*member) {
// CIR-BEFORE: cir.func {{.*}} @_Z5test3PK5PointMS_i(
// CIR-BEFORE-SAME: %[[PT_ARG:.*]]: !cir.ptr<!rec_Point>
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Point>
-// CIR-BEFORE: %[[PT_ADDR:.*]] = cir.alloca {{.*}} ["pt", init]
-// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca {{.*}} ["member", init]
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca {{.*}} ["__retval"]
+// CIR-BEFORE: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init
+// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
// CIR-BEFORE: cir.store %[[PT_ARG]], %[[PT_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[PT:.*]] = cir.load{{.*}} %[[PT_ADDR]]
@@ -166,9 +166,9 @@ int test3(const Point *pt, int Point::*member) {
// CIR-AFTER: cir.func {{.*}} @_Z5test3PK5PointMS_i(
// CIR-AFTER-SAME: %[[PT_ARG:.*]]: !cir.ptr<!rec_Point>
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Point>, !cir.ptr<!cir.ptr<!rec_Point>>, ["pt", init]
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["member", init]
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init !cir.ptr<!rec_Point> -> !cir.ptr<!cir.ptr<!rec_Point>>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-AFTER: cir.store %[[PT_ARG]], %[[PT_ADDR]] : !cir.ptr<!rec_Point>, !cir.ptr<!cir.ptr<!rec_Point>>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[PT:.*]] = cir.load{{.*}} %[[PT_ADDR]] : !cir.ptr<!cir.ptr<!rec_Point>>, !cir.ptr<!rec_Point>
@@ -214,8 +214,8 @@ auto test4(int Incomplete::*member) -> int Incomplete::* {
// CIR-BEFORE: cir.func {{.*}} @_Z5test4M10Incompletei(
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Incomplete>
-// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca {{.*}} ["member", init]
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca {{.*}} ["__retval"]
+// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[MEMBER:.*]] = cir.load{{.*}} %[[MEMBER_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER]], %[[RETVAL_ADDR]]
@@ -224,8 +224,8 @@ auto test4(int Incomplete::*member) -> int Incomplete::* {
// CIR-AFTER: cir.func {{.*}} @_Z5test4M10Incompletei(
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["member", init]
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["__retval"]
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s64i -> !cir.ptr<!s64i>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[MEMBER:.*]] = cir.load{{.*}} %[[MEMBER_ADDR]] : !cir.ptr<!s64i>, !s64i
// CIR-AFTER: cir.store %[[MEMBER]], %[[RETVAL_ADDR]] : !s64i, !cir.ptr<!s64i>
@@ -254,9 +254,9 @@ int test5(Incomplete *ic, int Incomplete::*member) {
// CIR-BEFORE: cir.func {{.*}} @_Z5test5P10IncompleteMS_i(
// CIR-BEFORE-SAME: %[[IC_ARG:.*]]: !cir.ptr<!rec_Incomplete>
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Incomplete>
-// CIR-BEFORE: %[[IC_ADDR:.*]] = cir.alloca {{.*}} ["ic", init]
-// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca {{.*}} ["member", init]
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca {{.*}} ["__retval"]
+// CIR-BEFORE: %[[IC_ADDR:.*]] = cir.alloca "ic" {{.*}} init
+// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
// CIR-BEFORE: cir.store %[[IC_ARG]], %[[IC_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[IC:.*]] = cir.load{{.*}} %[[IC_ADDR]]
@@ -270,9 +270,9 @@ int test5(Incomplete *ic, int Incomplete::*member) {
// CIR-AFTER: cir.func {{.*}} @_Z5test5P10IncompleteMS_i(
// CIR-AFTER-SAME: %[[IC_ARG:.*]]: !cir.ptr<!rec_Incomplete>
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[IC_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Incomplete>, !cir.ptr<!cir.ptr<!rec_Incomplete>>, ["ic", init]
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["member", init]
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR-AFTER: %[[IC_ADDR:.*]] = cir.alloca "ic" {{.*}} init !cir.ptr<!rec_Incomplete> -> !cir.ptr<!cir.ptr<!rec_Incomplete>>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-AFTER: cir.store %[[IC_ARG]], %[[IC_ADDR]] : !cir.ptr<!rec_Incomplete>, !cir.ptr<!cir.ptr<!rec_Incomplete>>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[IC:.*]] = cir.load{{.*}} %[[IC_ADDR]] : !cir.ptr<!cir.ptr<!rec_Incomplete>>, !cir.ptr<!rec_Incomplete>
@@ -315,7 +315,7 @@ auto test_null() -> int Point::* {
}
// CIR: cir.func {{.*}} @_Z9test_nullv() -> !cir.data_member<!s32i in !rec_Point> {
-// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca !cir.data_member<!s32i in !rec_Point>, !cir.ptr<!cir.data_member<!s32i in !rec_Point>>, ["__retval"]
+// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.data_member<!s32i in !rec_Point> -> !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
// CIR: %[[CONST_NULL:.*]] = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !rec_Point>
// CIR: cir.store %[[CONST_NULL]], %[[RETVAL_ADDR]]
// CIR: %[[RET:.*]] = cir.load %[[RETVAL_ADDR]]
@@ -335,7 +335,7 @@ auto test_null_incomplete() -> int Incomplete::* {
}
// CIR: cir.func {{.*}} @_Z20test_null_incompletev() -> !cir.data_member<!s32i in !rec_Incomplete> {
-// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca !cir.data_member<!s32i in !rec_Incomplete>, !cir.ptr<!cir.data_member<!s32i in !rec_Incomplete>>, ["__retval"]
+// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.data_member<!s32i in !rec_Incomplete> -> !cir.ptr<!cir.data_member<!s32i in !rec_Incomplete>>
// CIR: %[[CONST_NULL:.*]] = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !rec_Incomplete>
// CIR: cir.store %[[CONST_NULL]], %[[RETVAL_ADDR]]
// CIR: %[[RET:.*]] = cir.load %[[RETVAL_ADDR]]
diff --git a/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
index d4fdc10fc601a..b638c3b9ec421 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
@@ -135,8 +135,8 @@ DerivedMemFunc base_to_derived_zero_offset(Base1MemFunc ptr) {
// CIR-BEFORE: %{{.*}} = cir.derived_method %[[PTR]][0] : !cir.method<!cir.func<(!cir.ptr<!rec_Base1>, !s32i)> in !rec_Base1> -> !cir.method<!cir.func<(!cir.ptr<!rec_Derived>, !s32i)> in !rec_Derived>
// CIR-AFTER: cir.func {{.*}} @_Z27base_to_derived_zero_offsetM5Base1FviE
-// CIR-AFTER: %[[PTR:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["ptr", init]
-// CIR-AFTER: %[[RET:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__retval"]
+// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.store %{{.*}}, %[[PTR]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[PTR]] : !cir.ptr<!rec_anon_struct>, !rec_anon_struct
// CIR-AFTER: cir.store %[[TMP]], %[[RET]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -202,8 +202,8 @@ Base1MemFunc derived_to_base_zero_offset(DerivedMemFunc ptr) {
// CIR-BEFORE: %{{.*}} = cir.base_method %[[PTR]][0] : !cir.method<!cir.func<(!cir.ptr<!rec_Derived>, !s32i)> in !rec_Derived> -> !cir.method<!cir.func<(!cir.ptr<!rec_Base1>, !s32i)> in !rec_Base1>
// CIR-AFTER: cir.func {{.*}} @_Z27derived_to_base_zero_offsetM7DerivedFviE
-// CIR-AFTER: %[[PTR:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["ptr", init]
-// CIR-AFTER: %[[RET:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__retval"]
+// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.store %{{.*}}, %[[PTR]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[PTR]] : !cir.ptr<!rec_anon_struct>, !rec_anon_struct
// CIR-AFTER: cir.store %[[TMP]], %[[RET]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
diff --git a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
index ce694ca1040e7..1164220fb511c 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
@@ -62,14 +62,14 @@ auto make_non_virtual() -> void (Foo::*)(int) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z16make_non_virtualv() -> !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>, ["__retval"]
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[METHOD_PTR:.*]] = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[METHOD_PTR]], %[[RETVAL]]
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]]
// CIR-BEFORE: cir.return %[[RET]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-AFTER: cir.func {{.*}} @_Z16make_non_virtualv() -> !rec_anon_struct attributes {{{.*}}nothrow} {
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__retval"]
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[METHOD_PTR:.*]] = cir.get_global @[[NONVIRT_RET]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.copy %[[METHOD_PTR]] to %[[RETVAL]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]]
@@ -95,14 +95,14 @@ auto make_virtual() -> void (Foo::*)(int) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z12make_virtualv() -> !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>, ["__retval"]
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[METHOD_PTR:.*]] = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[METHOD_PTR]], %[[RETVAL]]
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.return %[[RET]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-AFTER: cir.func {{.*}} @_Z12make_virtualv() -> !rec_anon_struct
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__retval"]
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[METHOD_PTR:.*]] = cir.get_global @[[VIRT_RET]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.copy %[[METHOD_PTR]] to %[[RETVAL]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]]
@@ -126,14 +126,14 @@ auto make_null() -> void (Foo::*)(int) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z9make_nullv() -> !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>, ["__retval"]
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[METHOD_PTR:.*]] = cir.const #cir.method<null> : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[METHOD_PTR]], %[[RETVAL]]
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]]
// CIR-BEFORE: cir.return %[[RET]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-AFTER: cir.func {{.*}} @_Z9make_nullv() -> !rec_anon_struct
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca !rec_anon_struct, !cir.ptr<!rec_anon_struct>, ["__retval"]
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[METHOD_PTR:.*]] = cir.get_global @[[NULL_RET]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.copy %[[METHOD_PTR]] to %[[RETVAL]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]]
diff --git a/clang/test/CIR/CodeGen/replace-global.cpp b/clang/test/CIR/CodeGen/replace-global.cpp
index 709956d412873..24f946f31f604 100644
--- a/clang/test/CIR/CodeGen/replace-global.cpp
+++ b/clang/test/CIR/CodeGen/replace-global.cpp
@@ -55,7 +55,7 @@ char *get_ptr_to_element() { return ptrToElement; }
// CIR: cir.global {{.*}} @ptrToElement = #cir.global_view<@gSMulti, [0, 4, 1]> : !cir.ptr<
// CIR: cir.func {{.*}} @_Z15use_as_constantv()
-// CIR: %[[PTR_TO_S:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["ptrToS", init, const]
+// CIR: %[[PTR_TO_S:.*]] = cir.alloca "ptrToS" {{.*}} init const !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[GLOBAL_PTR:.*]] = cir.const #cir.global_view<@_ZL2gS> : !cir.ptr<!rec_S>
// CIR: cir.store{{.*}} %[[GLOBAL_PTR]], %[[PTR_TO_S]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
diff --git a/clang/test/CIR/CodeGen/requires-expr.cpp b/clang/test/CIR/CodeGen/requires-expr.cpp
index 36dca139f84a9..7f447ebebed2c 100644
--- a/clang/test/CIR/CodeGen/requires-expr.cpp
+++ b/clang/test/CIR/CodeGen/requires-expr.cpp
@@ -11,12 +11,12 @@ template <typename T> void summable(T a) {
}
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[ARG_A:.*]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.if %[[CONST_TRUE]] {
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP_A_1:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[TMP_A_2:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[RESULT:.*]] = cir.add nsw %[[TMP_A_1]], %[[TMP_A_2]] : !s32i
diff --git a/clang/test/CIR/CodeGen/self-assign.c b/clang/test/CIR/CodeGen/self-assign.c
index 0f9d093cad3ff..59c21733226a2 100644
--- a/clang/test/CIR/CodeGen/self-assign.c
+++ b/clang/test/CIR/CodeGen/self-assign.c
@@ -19,7 +19,7 @@ void test_self_initialize() {
}
// CIR: cir.func{{.*}} @test_self_initialize()
-// %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// cir.copy %[[S]] to %[[S]] : !cir.ptr<!rec_S>
// LLVM: define{{.*}} void @test_self_initialize()
diff --git a/clang/test/CIR/CodeGen/size-of-vla.cpp b/clang/test/CIR/CodeGen/size-of-vla.cpp
index c6838155189ef..19a4e86abce63 100644
--- a/clang/test/CIR/CodeGen/size-of-vla.cpp
+++ b/clang/test/CIR/CodeGen/size-of-vla.cpp
@@ -10,8 +10,8 @@ void vla_type_with_element_type_of_size_1() {
unsigned long size = sizeof(bool[n]);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init]
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["size", init]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
@@ -34,8 +34,8 @@ void vla_type_with_element_type_int() {
unsigned long size = sizeof(int[n]);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init]
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["size", init]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
@@ -63,16 +63,16 @@ void vla_expr_element_type_of_size_1() {
unsigned long size = sizeof(arr);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init]
-// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["size", init]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
// CIR: %[[STACK_SAVE:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_SAVE]], %[[SAVED_STACK_ADDR]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, %[[TMP_N]] : !u64i, ["arr"]
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} %[[TMP_N]] : !u64i, !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.store {{.*}} %[[TMP_N]], %[[SIZE_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: cir.yield
// CIR: } cleanup normal {
@@ -115,16 +115,16 @@ void vla_expr_element_type_int() {
unsigned long size = sizeof(arr);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init]
-// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["size", init]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
// CIR: %[[STACK_SAVE:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_SAVE]], %[[SAVED_STACK_ADDR]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[TMP_N]] : !u64i, ["arr"]
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} %[[TMP_N]] : !u64i, !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_4:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[SIZE:.*]] = cir.mul nuw %[[CONST_4]], %[[TMP_N]] : !u64i
// CIR: cir.store {{.*}} %[[SIZE]], %[[SIZE_ADDR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/source-loc.cpp b/clang/test/CIR/CodeGen/source-loc.cpp
index b811964eca3b8..149834d560cf9 100644
--- a/clang/test/CIR/CodeGen/source-loc.cpp
+++ b/clang/test/CIR/CodeGen/source-loc.cpp
@@ -69,8 +69,8 @@ void line_column() {
unsigned int b = __builtin_COLUMN();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CIR: %[[CONST_9:.*]] = cir.const #cir.int<68> : !u32i
// CIR: cir.store {{.*}} %[[CONST_9]], %[[A_ADDR]] : !u32i, !cir.ptr<!u32i>
// CIR: %[[CONST_20:.*]] = cir.const #cir.int<20> : !u32i
@@ -92,9 +92,9 @@ void function_file() {
const char *c = __builtin_FILE_NAME();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[FUNC__GV:.*]] = cir.const #cir.global_view<@".str.3"> : !cir.ptr<!s8i>
// CIR: cir.store {{.*}} %[[FUNC__GV]], %[[A_ADDR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[FILE_PATH_GV:.*]] = cir.const #cir.global_view<@".str"> : !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/statement-exprs.c b/clang/test/CIR/CodeGen/statement-exprs.c
index 8e835c9ad5e3b..7ff41bd5c5159 100644
--- a/clang/test/CIR/CodeGen/statement-exprs.c
+++ b/clang/test/CIR/CodeGen/statement-exprs.c
@@ -13,8 +13,8 @@ int f19(void) {
// LLVM-DAG: @[[TEST3_S:.*]] = private constant %struct.S { i32 1 }
// CIR: cir.func {{.*}} @f19() -> !s32i
-// CIR: %[[RETVAL:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[TMP:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp"]
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
// CIR: %[[C4:.+]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store {{.*}} %[[C4]], %[[TMP]] : !s32i, !cir.ptr<!s32i>
@@ -64,23 +64,23 @@ int nested(void) {
}
// CIR: cir.func {{.*}} @nested() -> !s32i
-// CIR: %[[RETVAL:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[TMP_OUTER:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp"]
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP_OUTER:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
// CIR: %[[C123_OUTER:.+]] = cir.const #cir.int<123> : !s32i
// CIR: cir.store {{.*}} %[[C123_OUTER]], %[[TMP_OUTER]] : !s32i, !cir.ptr<!s32i>
// CIR: }
// CIR: %[[LOAD_TMP_OUTER:.+]] = cir.load {{.*}} %[[TMP_OUTER]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.scope {
-// CIR: %[[BAR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["bar", init]
-// CIR: %[[TMP_BARRET:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp"]
+// CIR: %[[BAR:.+]] = cir.alloca "bar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP_BARRET:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[C987:.+]] = cir.const #cir.int<987> : !s32i
// CIR: cir.store {{.*}} %[[C987]], %[[BAR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[TMP1:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp"]
-// CIR: %[[TMP2:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp"]
+// CIR: %[[TMP1:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP2:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[ASDF:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["asdf", init]
+// CIR: %[[ASDF:.+]] = cir.alloca "asdf" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[C123_INNER:.+]] = cir.const #cir.int<123> : !s32i
// CIR: cir.store {{.*}} %[[C123_INNER]], %[[ASDF]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[LOAD_ASDF:.+]] = cir.load {{.*}} %[[ASDF]] : !cir.ptr<!s32i>, !s32i
@@ -194,9 +194,9 @@ void empty2() { ({ }); }
// Yields an out-of-scope scalar.
void test2() { ({int x = 3; x; }); }
// CIR: cir.func {{.*}} @test2
-// CIR: %[[RETVAL:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.+]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[VAR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[VAR:.+]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// [...]
// CIR: %[[TMP:.+]] = cir.load{{.*}} %[[VAR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[TMP]], %[[RETVAL]] : !s32i, !cir.ptr<!s32i>
@@ -229,11 +229,11 @@ void test2() { ({int x = 3; x; }); }
struct S { int x; };
int test3() { return ({ struct S s = {1}; s; }).x; }
// CIR: cir.func {{.*}} @test3() -> !s32i
-// CIR: %[[RETVAL:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[REF_TMP0:.+]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["ref.tmp0"]
-// CIR: %[[TMP:.+]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["tmp"]
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[REF_TMP0:.+]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.scope {
-// CIR: %[[S:.+]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// CIR: %[[S:.+]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR: %[[CONST:.*]] = cir.get_global @[[TEST3_S]] : !cir.ptr<!rec_S>
// CIR: cir.copy %[[CONST]] to %[[S]] : !cir.ptr<!rec_S>
// CIR: cir.copy %[[S]] to %[[REF_TMP0]] : !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/static-local-arm-guard.cpp b/clang/test/CIR/CodeGen/static-local-arm-guard.cpp
index e7abb7fb51739..d531c3d5aa8dc 100644
--- a/clang/test/CIR/CodeGen/static-local-arm-guard.cpp
+++ b/clang/test/CIR/CodeGen/static-local-arm-guard.cpp
@@ -56,7 +56,7 @@ inline int word_guard() {
}
// CIR: cir.func {{.*}} @_Z10word_guardv()
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[B:.*]] = cir.get_global static_local @_ZZ10word_guardvE1b : !cir.ptr<!s32i>
// CIR: %[[GUARD:.*]] = cir.get_global @_ZGVZ10word_guardvE1b : !cir.ptr<!s64i>
// CIR: %[[GUARD_BYTE_PTR:.*]] = cir.cast bitcast %[[GUARD]] : !cir.ptr<!s64i> -> !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/static-local.cpp b/clang/test/CIR/CodeGen/static-local.cpp
index 4f5bd112554cc..4ace38a4cfdf2 100644
--- a/clang/test/CIR/CodeGen/static-local.cpp
+++ b/clang/test/CIR/CodeGen/static-local.cpp
@@ -188,7 +188,7 @@ void references_param_and_previous(int param) {
static int refs_magic_static = magic_static;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z29references_param_and_previousi
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["param", init]
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_MAG_STATIC:.*]] = cir.get_global static_local @_ZZ29references_param_and_previousiE12magic_static : !cir.ptr<!s32i>
//
// CIR-BEFORE-LPP: cir.local_init static_local @_ZZ29references_param_and_previousiE12magic_static ctor {
@@ -279,9 +279,9 @@ void multi_refs(int one, int two, int, int three, int, int four, int) {
static A magic_static = one + three + four + bar();
static A refs_magic_static = magic_static;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z10multi_refsiiiiiii(
-// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["one", init]
-// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["three", init]
-// CIR-BOTH: %[[FOUR_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["four", init]
+// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca "three" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[FOUR_ALLOCA:.*]] = cir.alloca "four" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_MS:.*]] = cir.get_global static_local @_ZZ10multi_refsiiiiiiiE12magic_static : !cir.ptr<!rec_A>
// CIR-BEFORE-LPP: cir.local_init static_local @_ZZ10multi_refsiiiiiiiE12magic_static ctor {
//
@@ -387,10 +387,10 @@ void InMember::mem_func(int one, int two, int, int three) {
int some_local = mem_get_int();
static int magic_static = three + mem_get_int() + one + some_local;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_ZN8InMember8mem_funcEiiii(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_InMember>, !cir.ptr<!cir.ptr<!rec_InMember>>, ["this", init]
-// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["one", init]
-// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["three", init]
-// CIR-BOTH: %[[LOCAL_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["some_local", init]
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_InMember> -> !cir.ptr<!cir.ptr<!rec_InMember>>
+// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca "three" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[LOCAL_ALLOCA:.*]] = cir.alloca "some_local" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_InMember>>, !cir.ptr<!rec_InMember>
// CIR-BOTH: %[[GET_INT:.*]] = cir.call @_ZN8InMember11mem_get_intEv(%[[THIS_LOAD]]) : (!cir.ptr<!rec_InMember>{{.*}}) -> (!s32i {llvm.noundef})
// CIR-BOTH: cir.store{{.*}} %[[GET_INT]], %[[LOCAL_ALLOCA]] : !s32i, !cir.ptr<!s32i>
@@ -461,7 +461,7 @@ void InMember::mem_func(int one, int two, int, int three) {
void self_ref(int one) {
static int magic_static = magic_static + one;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z8self_refi(
-// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["one", init]
+// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_MS:.*]] = cir.get_global static_local @_ZZ8self_refiE12magic_static : !cir.ptr<!s32i>
//
// CIR-BEFORE-LPP: cir.local_init static_local @_ZZ8self_refiE12magic_static ctor {
@@ -630,8 +630,8 @@ int referenced_inside() {
auto lam = []() { return static_local; };
return lam();
// CIR-BOTH-LABEL: cir.func no_inline lambda internal private dso_local @_ZZ17referenced_insidevENK3$_0clEv(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!{{.*}}>, !cir.ptr<!cir.ptr<!{{.*}}>>, ["this", init]
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!{{.*}}> -> !cir.ptr<!cir.ptr<!{{.*}}>>
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_THIS:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!{{.*}}>>, !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global static_local @_ZZ17referenced_insidevE12static_local : !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_SL:.*]] = cir.load {{.*}}%[[GET_SL]] : !cir.ptr<!s32i>, !s32i
@@ -641,8 +641,8 @@ int referenced_inside() {
// CIR-BOTH: }
//
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z17referenced_insidev()
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca !{{.*}}, !cir.ptr<!{{.*}}>, ["lam"]
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca "lam" {{.*}} !{{.*}} -> !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global static_local @_ZZ17referenced_insidevE12static_local : !cir.ptr<!s32i>
// CIR-BEFORE-LLP: cir.local_init static_local @_ZZ17referenced_insidevE12static_local ctor {
//
@@ -712,8 +712,8 @@ int referenced_inside_const() {
auto lam = []() { return static_local; };
return lam();
// CIR-BOTH-LABEL: cir.func no_inline lambda internal private dso_local @_ZZ23referenced_inside_constvENK3$_0clEv(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca !cir.ptr<!{{.*}}>, !cir.ptr<!cir.ptr<!{{.*}}>>, ["this", init]
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!{{.*}}> -> !cir.ptr<!cir.ptr<!{{.*}}>>
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_THIS:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!{{.*}}>>, !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global @_ZZ23referenced_inside_constvE12static_local : !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_SL:.*]] = cir.load {{.*}}%[[GET_SL]] : !cir.ptr<!s32i>, !s32i
@@ -723,8 +723,8 @@ int referenced_inside_const() {
// CIR-BOTH: }
//
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z23referenced_inside_constv()
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca !{{.*}}, !cir.ptr<!{{.*}}>, ["lam"]
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca "lam" {{.*}} !{{.*}} -> !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global @_ZZ23referenced_inside_constvE12static_local : !cir.ptr<!s32i>
// CIR-BOTH-NOT: static_local
// CIR-BOTH-NOT: atomic
diff --git a/clang/test/CIR/CodeGen/stmt-expr.cpp b/clang/test/CIR/CodeGen/stmt-expr.cpp
index 3ef111c4baeb1..2fdb502fb73fb 100644
--- a/clang/test/CIR/CodeGen/stmt-expr.cpp
+++ b/clang/test/CIR/CodeGen/stmt-expr.cpp
@@ -21,10 +21,10 @@ void test1() {
}
// CIR: cir.func {{.*}} @_Z5test1v()
-// CIR: %[[REF_TMP0:.+]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["ref.tmp0"]
-// CIR: %[[TMP:.+]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["tmp"]
+// CIR: %[[REF_TMP0:.+]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} !rec_A -> !cir.ptr<!rec_A>
// CIR: cir.scope {
-// CIR: %[[A:.+]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["a", init]
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init !rec_A -> !cir.ptr<!rec_A>
// CIR: cir.call @_ZN1AC2Ev(%[[A]]) : (!cir.ptr<!rec_A> {{.*}}) -> ()
// CIR: cir.call @_ZN1AC2ERS_(%[[REF_TMP0]], %[[A]]) : (!cir.ptr<!rec_A> {{.*}}, !cir.ptr<!rec_A> {{.*}}) -> ()
// CIR: }
@@ -63,7 +63,7 @@ void cleanup() {
// CIR: cir.func {{.*}} @_Z7cleanupv()
// CIR: cir.scope {
-// CIR: %[[WD:.+]] = cir.alloca !rec_with_dtor, !cir.ptr<!rec_with_dtor>, ["wd"]
+// CIR: %[[WD:.+]] = cir.alloca "wd" {{.*}} !rec_with_dtor -> !cir.ptr<!rec_with_dtor>
// CIR: cir.cleanup.scope {
// CIR: cir.yield
// CIR: } cleanup normal {
@@ -92,10 +92,10 @@ void gnu_statement_extension() {
float b = __real__ ({float _Complex a; a;});
}
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
-// CIR: %[[TMP_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["tmp"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[TMP_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.scope {
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: cir.store {{.*}} %[[TMP_A]], %[[TMP_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: }
diff --git a/clang/test/CIR/CodeGen/string-literals.cpp b/clang/test/CIR/CodeGen/string-literals.cpp
index eea41a781efad..8f5f5db938d57 100644
--- a/clang/test/CIR/CodeGen/string-literals.cpp
+++ b/clang/test/CIR/CodeGen/string-literals.cpp
@@ -58,7 +58,7 @@ decltype(auto) returns_literal() {
}
// CIR: cir.func{{.*}} @_Z15returns_literalv() -> (!cir.ptr<!cir.array<!s8i x 5>>{{.*}})
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.ptr<!cir.array<!s8i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s8i x 5>>>, ["__retval"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s8i x 5>>>
// CIR: %[[STR_ADDR:.*]] = cir.get_global @[[STR5_GLOBAL]] : !cir.ptr<!cir.array<!s8i x 5>>
// CIR: cir.store{{.*}} %[[STR_ADDR]], %[[RET_ADDR]]
// CIR: %[[RET:.*]] = cir.load %[[RET_ADDR]]
diff --git a/clang/test/CIR/CodeGen/struct-init.cpp b/clang/test/CIR/CodeGen/struct-init.cpp
index 24feb3f8c8f34..6b55ee54bd1fe 100644
--- a/clang/test/CIR/CodeGen/struct-init.cpp
+++ b/clang/test/CIR/CodeGen/struct-init.cpp
@@ -79,8 +79,8 @@ void init() {
}
// CIR: cir.func{{.*}} @_Z4initv()
-// CIR: %[[S1:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s1", init]
-// CIR: %[[S2:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s2", init]
+// CIR: %[[S1:.*]] = cir.alloca "s1" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S2:.*]] = cir.alloca "s2" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR: %[[CONST_1:.*]] = cir.get_global @[[INIT_S1]] : !cir.ptr<!rec_S>
// CIR: cir.copy %[[CONST_1]] to %[[S1]] : !cir.ptr<!rec_S>
// CIR: %[[CONST_2:.*]] = cir.get_global @[[INIT_S2]] : !cir.ptr<!rec_S>
@@ -106,9 +106,9 @@ void init_var(int a, int b) {
}
// CIR: cir.func{{.*}} @_Z8init_varii(%[[A_ARG:.*]]: !s32i {{.*}}, %[[B_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.store{{.*}} %[[A_ARG]], %[[A_PTR]]
// CIR: cir.store{{.*}} %[[B_ARG]], %[[B_PTR]]
// CIR: %[[S_A:.*]] = cir.get_member %[[S]][0] {name = "a"}
@@ -154,10 +154,10 @@ void init_expr(int a, int b, int c) {
}
// CIR: cir.func{{.*}} @_Z9init_expriii(%[[A_ARG:.*]]: !s32i {{.*}}, %[[B_ARG:.*]]: !s32i {{.*}}, %[[C_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[C_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
-// CIR: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[C_PTR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.store{{.*}} %[[A_ARG]], %[[A_PTR]]
// CIR: cir.store{{.*}} %[[B_ARG]], %[[B_PTR]]
// CIR: cir.store{{.*}} %[[C_ARG]], %[[C_PTR]]
@@ -230,7 +230,7 @@ void cxx_default_init_with_struct_field() {
Parent p = Parent{};
}
-// CIR: %[[P_ADDR:.*]] = cir.alloca !rec_Parent, !cir.ptr<!rec_Parent>, ["p", init]
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !rec_Parent -> !cir.ptr<!rec_Parent>
// CIR: %[[P_ELEM_0_PTR:.*]] = cir.get_member %[[P_ADDR]][0] {name = "a"} : !cir.ptr<!rec_Parent> -> !cir.ptr<!s32i>
// CIR: %[[METHOD_CALL:.*]] = cir.call @_ZZ34cxx_default_init_with_struct_fieldvEN6Parent4getAEv(%[[P_ADDR]]) : (!cir.ptr<!rec_Parent>{{.*}}) -> (!s32i {llvm.noundef})
// CIR: cir.store{{.*}} %[[METHOD_CALL]], %[[P_ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c
index a3bde3ea42a81..e2f92255625db 100644
--- a/clang/test/CIR/CodeGen/struct.c
+++ b/clang/test/CIR/CodeGen/struct.c
@@ -167,7 +167,7 @@ void f(void) {
}
// CIR: cir.func{{.*}} @f()
-// CIR-NEXT: cir.alloca !cir.ptr<!rec_IncompleteS>, !cir.ptr<!cir.ptr<!rec_IncompleteS>>, ["p"] {alignment = 8 : i64}
+// CIR-NEXT: cir.alloca "p" align(8) !cir.ptr<!rec_IncompleteS> -> !cir.ptr<!cir.ptr<!rec_IncompleteS>>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @f()
@@ -184,7 +184,7 @@ void f2(void) {
}
// CIR: cir.func{{.*}} @f2()
-// CIR-NEXT: cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["s"] {alignment = 4 : i64}
+// CIR-NEXT: cir.alloca "s" align(4) !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @f2()
@@ -202,8 +202,8 @@ char f3(int a) {
}
// CIR: cir.func{{.*}} @f3(%[[ARG_A:.*]]: !s32i
-// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca {{.*}} ["a", init] {alignment = 4 : i64}
-// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca {{.*}} ["__retval"] {alignment = 1 : i64}
+// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" align(4) init
+// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(1)
// CIR-NEXT: cir.store{{.*}} %[[ARG_A]], %[[A_ADDR]]
// CIR-NEXT: %[[A_VAL:.*]] = cir.load{{.*}} %[[A_ADDR]]
// CIR-NEXT: %[[CS:.*]] = cir.get_global @cs
@@ -242,9 +242,9 @@ char f4(int a, struct CompleteS *p) {
}
// CIR: cir.func{{.*}} @f4(%[[ARG_A:.*]]: !s32i {{.*}}, %[[ARG_P:.*]]: !cir.ptr<!rec_CompleteS>
-// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca {{.*}} ["a", init] {alignment = 4 : i64}
-// CIR-NEXT: %[[P_ADDR:.*]] = cir.alloca {{.*}} ["p", init] {alignment = 8 : i64}
-// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca {{.*}} ["__retval"] {alignment = 1 : i64}
+// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" align(4) init
+// CIR-NEXT: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init
+// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(1)
// CIR-NEXT: cir.store{{.*}} %[[ARG_A]], %[[A_ADDR]]
// CIR-NEXT: cir.store{{.*}} %[[ARG_P]], %[[P_ADDR]]
// CIR-NEXT: %[[A_VAL:.*]] = cir.load{{.*}} %[[A_ADDR]]
diff --git a/clang/test/CIR/CodeGen/struct.cpp b/clang/test/CIR/CodeGen/struct.cpp
index 1c86a856d04a5..3bfc583f6ccb9 100644
--- a/clang/test/CIR/CodeGen/struct.cpp
+++ b/clang/test/CIR/CodeGen/struct.cpp
@@ -37,7 +37,7 @@ void f(void) {
}
// CIR: cir.func{{.*}} @_Z1fv()
-// CIR-NEXT: cir.alloca !cir.ptr<!rec_IncompleteS>, !cir.ptr<!cir.ptr<!rec_IncompleteS>>, ["p"]
+// CIR-NEXT: cir.alloca "p" {{.*}} !cir.ptr<!rec_IncompleteS> -> !cir.ptr<!cir.ptr<!rec_IncompleteS>>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @_Z1fv()
@@ -54,7 +54,7 @@ char f2(CompleteS &s) {
}
// CIR: cir.func{{.*}} @_Z2f2R9CompleteS(%[[ARG_S:.*]]: !cir.ptr<!rec_CompleteS>{{.*}})
-// CIR: %[[S_ADDR:.*]] = cir.alloca !cir.ptr<!rec_CompleteS>, !cir.ptr<!cir.ptr<!rec_CompleteS>>, ["s", init, const]
+// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<!rec_CompleteS> -> !cir.ptr<!cir.ptr<!rec_CompleteS>>
// CIR: cir.store %[[ARG_S]], %[[S_ADDR]]
// CIR: %[[S_REF:.*]] = cir.load{{.*}} %[[S_ADDR]]
// CIR: %[[S_ADDR2:.*]] = cir.get_member %[[S_REF]][1] {name = "b"}
@@ -89,7 +89,7 @@ void f3() {
}
// CIR: cir.func{{.*}} @_Z2f3v()
-// CIR: %[[O:.*]] = cir.alloca !rec_Outer, !cir.ptr<!rec_Outer>, ["o"]
+// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} !rec_Outer -> !cir.ptr<!rec_Outer>
// CIR: %[[O_I:.*]] = cir.get_member %[[O]][0] {name = "i"}
// CIR: %[[O_I_N:.*]] = cir.get_member %[[O_I]][0] {name = "n"}
@@ -114,8 +114,8 @@ void paren_expr() {
}
// CIR: cir.func{{.*}} @_Z10paren_exprv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_Point, !cir.ptr<!rec_Point>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !rec_Point, !cir.ptr<!rec_Point>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
// CIR: %[[CONST:.*]] = cir.get_global @[[PAREN_A]] : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]] : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[A_ADDR]] to %[[B_ADDR]] : !cir.ptr<!rec_Point>
@@ -139,9 +139,9 @@ void choose_expr() {
}
// CIR: cir.func{{.*}} @_Z11choose_exprv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[A_ADDR]] to %[[C_ADDR]] : !cir.ptr<!rec_CompleteS>
// LLVM: define{{.*}} void @_Z11choose_exprv()
@@ -164,10 +164,10 @@ void generic_selection() {
}
// CIR: cir.func{{.*}} @_Z17generic_selectionv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c"]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["d", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[A_ADDR]] to %[[D_ADDR]] : !cir.ptr<!rec_CompleteS>
// LLVM: define{{.*}} void @_Z17generic_selectionv()
@@ -192,8 +192,8 @@ void designated_init_update_expr() {
} b = {a, .c.a = 1};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !rec_Container, !cir.ptr<!rec_Container>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !rec_Container -> !cir.ptr<!rec_Container>
// CIR: %[[C_ADDR:.*]] = cir.get_member %[[B_ADDR]][0] {name = "c"} : !cir.ptr<!rec_Container> -> !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[A_ADDR]] to %[[C_ADDR]] : !cir.ptr<!rec_CompleteS>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[C_ADDR]][0] {name = "a"} : !cir.ptr<!rec_CompleteS> -> !cir.ptr<!s32i>
@@ -223,7 +223,7 @@ void atomic_init() {
}
// CIR: cir.func{{.*}} @_Z11atomic_initv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[A_ADDR]][0] {name = "a"} : !cir.ptr<!rec_CompleteS> -> !cir.ptr<!s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[CONST_0]], %[[ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
@@ -249,7 +249,7 @@ void unary_extension() {
CompleteS a = __extension__ CompleteS();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: %[[ZERO_INIT:.*]] = cir.get_global @[[UNARY_A:.*]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[ZERO_INIT]] to %[[A_ADDR]] : !cir.ptr<!rec_CompleteS>
@@ -264,7 +264,7 @@ void bin_comma() {
}
// CIR: cir.func{{.*}} @_Z9bin_commav()
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: %[[CONST:.*]] = cir.get_global @[[COMMA_A:.*]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]] : !cir.ptr<!rec_CompleteS>
@@ -278,7 +278,7 @@ void bin_comma() {
void compound_literal_expr() { CompleteS a = (CompleteS){}; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: %[[CONST:.*]] = cir.get_global @[[COMPLIT_A:.*]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]] : !cir.ptr<!rec_CompleteS>
@@ -298,8 +298,8 @@ void struct_with_const_member_expr() {
int a = (StructWithConstMember){}.a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[REF_ADDR:.*]] = cir.alloca !rec_StructWithConstMember, !cir.ptr<!rec_StructWithConstMember>, ["ref.tmp0"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[REF_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_StructWithConstMember -> !cir.ptr<!rec_StructWithConstMember>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[REF_ADDR]][0] {name = "a"} : !cir.ptr<!rec_StructWithConstMember> -> !cir.ptr<!u8i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[SET_BF:.*]] = cir.set_bitfield{{.*}} (#bfi_a, %[[ELEM_0_PTR]] : !cir.ptr<!u8i>, %[[CONST_0]] : !s32i) -> !s32i
@@ -327,7 +327,7 @@ void struct_with_const_member_expr() {
void function_arg_with_default_value(CompleteS a = {1, 2}) {}
-// CIR: %[[ARG_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["a", init]
+// CIR: %[[ARG_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: cir.store %{{.*}}, %[[ARG_ADDR]] : !rec_CompleteS, !cir.ptr<!rec_CompleteS>
// LLVM: %[[ARG_ADDR:.*]] = alloca %struct.CompleteS, i64 1, align 4
@@ -340,7 +340,7 @@ void calling_function_with_default_values() {
function_arg_with_default_value();
}
-// CIR: %[[AGG_ADDR:.*]] = cir.alloca !rec_CompleteS, !cir.ptr<!rec_CompleteS>, ["agg.tmp0"]
+// CIR: %[[AGG_ADDR:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[AGG_ADDR]][0] {name = "a"} : !cir.ptr<!rec_CompleteS> -> !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/switch.cpp b/clang/test/CIR/CodeGen/switch.cpp
index 3449645643d82..a665945265479 100644
--- a/clang/test/CIR/CodeGen/switch.cpp
+++ b/clang/test/CIR/CodeGen/switch.cpp
@@ -27,7 +27,7 @@ void sw1(int a) {
// CIR-NEXT: cir.break
// CIR: cir.case(equal, [#cir.int<2> : !s32i]) {
// CIR: cir.scope {
-// CIR: cir.alloca !s32i, !cir.ptr<!s32i>, ["yolo", init]
+// CIR: cir.alloca "yolo" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.break
// LLVM: define{{.*}} void @_Z3sw1i
@@ -99,8 +99,8 @@ void sw2(int a) {
// CIR: cir.func{{.*}} @_Z3sw2i
// CIR: cir.scope {
-// CIR-NEXT: %[[YOLO:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["yolo", init]
-// CIR-NEXT: %[[FOMO:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["fomo", init]
+// CIR-NEXT: %[[YOLO:.*]] = cir.alloca "yolo" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[FOMO:.*]] = cir.alloca "fomo" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.switch(%[[COND:.*]] : !s32i) {
// CIR-NEXT: cir.case(equal, [#cir.int<3> : !s32i]) {
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -405,7 +405,7 @@ void sw7(int a) {
}
// CIR: cir.func{{.*}} @_Z3sw7i
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.switch(%[[A:.*]] : !s32i)
// CIR-NEXT: cir.case(equal, [#cir.int<0> : !s32i]) {
// CIR-NEXT: cir.yield
@@ -978,7 +978,7 @@ void sw15(int x) {
}
// CIR: cir.func{{.*}} @_Z4sw15i
-// CIR: %[[Y:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y"]
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.switch
// CIR-NEXT: cir.case(equal, [#cir.int<1> : !s32i]) {
// CIR-NEXT: cir.yield
diff --git a/clang/test/CIR/CodeGen/switch_flat_op.cpp b/clang/test/CIR/CodeGen/switch_flat_op.cpp
index 97dc96f8ac6b9..e41266534df74 100644
--- a/clang/test/CIR/CodeGen/switch_flat_op.cpp
+++ b/clang/test/CIR/CodeGen/switch_flat_op.cpp
@@ -19,7 +19,7 @@ void swf(int a) {
}
// BEFORE: cir.func{{.*}} @_Z3swfi
-// BEFORE: %[[VAR_B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
+// BEFORE: %[[VAR_B:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
// BEFORE: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
// BEFORE: cir.switch(%[[COND:.*]] : !s32i) {
// BEFORE: cir.case(equal, [#cir.int<3> : !s32i]) {
@@ -45,9 +45,9 @@ void swf(int a) {
// BEFORE: cir.return
// AFTER: cir.func{{.*}} @_Z3swfi
-// AFTER: %[[VAR_A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+// AFTER: %[[VAR_A:.*]] = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
// AFTER: cir.store{{.*}} %arg0, %[[VAR_A]] : !s32i, !cir.ptr<!s32i>
-// AFTER: %[[VAR_B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
+// AFTER: %[[VAR_B:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
// AFTER: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
// AFTER: cir.store{{.*}} %[[CONST_3]], %[[VAR_B]] : !s32i, !cir.ptr<!s32i>
// AFTER: cir.switch.flat %[[COND:.*]] : !s32i, ^bb[[#BB6:]] [
diff --git a/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp b/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp
index 192c683e57b29..f9faa948d31bc 100644
--- a/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp
+++ b/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp
@@ -26,7 +26,7 @@ const auto *ptr = get_ptr<HasMem{3}>();
template<HasMem m>
int get_x() { return m.x; }
// CIR-LABEL: cir.func {{.*}}@_Z5get_xIXtl6HasMemLi1EEEEiv()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// Note: This is emitted as an 'ignored' expression, but we cannot omit it,
// since it might be used in an example like below.
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZTAXtl6HasMemLi1EEE : !cir.ptr<!rec_HasMem>
@@ -43,7 +43,7 @@ int get_x() { return m.x; }
template<HasMem m>
HasMem get_m() { return m; }
// CIR-LABEL: cir.func {{.*}}@_Z5get_mIXtl6HasMemLi2EEEES0_v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca !rec_HasMem, !cir.ptr<!rec_HasMem>, ["__retval"] {alignment = 4 : i64}
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(4) !rec_HasMem -> !cir.ptr<!rec_HasMem>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZTAXtl6HasMemLi2EEE : !cir.ptr<!rec_HasMem>
// CIR: cir.copy %[[GET_GLOB]] to %[[RET_ALLOCA]] : !cir.ptr<!rec_HasMem>
//
diff --git a/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp b/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp
index b4761f56300b4..73218a5ed02f3 100644
--- a/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp
+++ b/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp
@@ -11,8 +11,8 @@ void Field() {
const int &r = Base().x;
}
// CIR-LABEL: cir.func {{.*}}@_Z5Fieldv()
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca !rec_Base, !cir.ptr<!rec_Base>, ["ref.tmp0"]
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["r", init, const]
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Base -> !cir.ptr<!rec_Base>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_MEM:.*]] = cir.get_member %[[TEMP_ALLOCA]][0] {name = "x"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: cir.store align(8) %[[GET_MEM]], %[[R_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -26,9 +26,9 @@ void MemPtr(int Base::*mp) {
const int &r = Base().*mp;
}
// CIR-LABEL: cir.func {{.*}}@_Z6MemPtrM4Basei
-// CIR: %[[MP_ALLOCA:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["mp", init] {alignment = 8 : i64}
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca !rec_Base, !cir.ptr<!rec_Base>, ["ref.tmp0"] {alignment = 4 : i64}
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["r", init, const] {alignment = 8 : i64}
+// CIR: %[[MP_ALLOCA:.*]] = cir.alloca "mp" align(8) init !s64i -> !cir.ptr<!s64i>
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) !rec_Base -> !cir.ptr<!rec_Base>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" align(8) init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[ARG_LOAD:.*]] = cir.load align(8) %[[MP_ALLOCA]] : !cir.ptr<!s64i>, !s64i
// CIR: %[[TEMP_LOAD:.*]] = cir.cast bitcast %[[TEMP_ALLOCA]] : !cir.ptr<!rec_Base> -> !cir.ptr<!s8i>
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ARG_LOAD]] : (!cir.ptr<!s8i>, !s64i) -> !cir.ptr<!s8i>
@@ -48,8 +48,8 @@ void DerivedToBase() {
const int &r = Derived().x;
}
// CIR-LABEL: cir.func {{.*}}@_Z13DerivedToBasev()
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["ref.tmp0"] {alignment = 4 : i64}
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["r", init, const] {alignment = 8 : i64}
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) !rec_Derived -> !cir.ptr<!rec_Derived>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" align(8) init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TEMP_ALLOCA]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[GET_MEM:.*]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: cir.store align(8) %[[GET_MEM]], %[[R_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGen/temporary-materialization.cpp b/clang/test/CIR/CodeGen/temporary-materialization.cpp
index 405decfc7a0cf..04beef92628b3 100644
--- a/clang/test/CIR/CodeGen/temporary-materialization.cpp
+++ b/clang/test/CIR/CodeGen/temporary-materialization.cpp
@@ -13,8 +13,8 @@ int test() {
}
// CIR: cir.func {{.*}} @_Z4testv()
-// CIR: %[[TEMP_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp0", init]
-// CIR-NEXT: %[[X:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["x", init, const]
+// CIR: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[X:.*]] = cir.alloca "x" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[TEMP_VALUE:.*]] = cir.call @_Z8make_intv() : () -> (!s32i {llvm.noundef})
// CIR-NEXT: cir.store{{.*}} %[[TEMP_VALUE]], %[[TEMP_SLOT]]
// CIR-NEXT: cir.store{{.*}} %[[TEMP_SLOT]], %[[X]]
@@ -44,10 +44,10 @@ int test_scoped() {
}
// CIR: cir.func {{.*}} @_Z11test_scopedv()
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR-NEXT: %[[TEMP_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["ref.tmp0", init]
-// CIR-NEXT: %[[Y_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["y", init, const]
+// CIR-NEXT: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[TEMP_VALUE:.*]] = cir.call @_Z8make_intv() : () -> (!s32i {llvm.noundef})
// CIR-NEXT: cir.store{{.*}} %[[TEMP_VALUE]], %[[TEMP_SLOT]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[TEMP_SLOT]], %[[Y_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGen/ternary-throw.cpp b/clang/test/CIR/CodeGen/ternary-throw.cpp
index 3a0d221d608a0..0f58e2ab5efa4 100644
--- a/clang/test/CIR/CodeGen/ternary-throw.cpp
+++ b/clang/test/CIR/CodeGen/ternary-throw.cpp
@@ -11,8 +11,8 @@ const int& test_cond_throw_false(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z21test_cond_throw_falseb(
-// CIR: %[[FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["flag", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init, const]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
// CIR: %[[TEN:.*]] = cir.const #cir.int<10> : !s32i
// CIR: cir.store{{.*}} %[[TEN]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
@@ -74,8 +74,8 @@ const int& test_cond_throw_true(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z20test_cond_throw_trueb(
-// CIR: %[[FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["flag", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init, const]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
// CIR: %[[TEN:.*]] = cir.const #cir.int<10> : !s32i
// CIR: cir.store{{.*}} %[[TEN]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
@@ -138,7 +138,7 @@ const int& test_cond_const_true_throw_false() {
}
// CIR-LABEL: cir.func{{.*}} @_Z32test_cond_const_true_throw_falsev(
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init, const]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
// CIR: %[[TWENTY:.*]] = cir.const #cir.int<20> : !s32i
// CIR: cir.store{{.*}} %[[TWENTY]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
@@ -170,7 +170,7 @@ const int& test_cond_const_false_throw_true() {
}
// CIR-LABEL: cir.func{{.*}} @_Z32test_cond_const_false_throw_truev(
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init, const]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
// CIR: %[[THIRTY:.*]] = cir.const #cir.int<30> : !s32i
// CIR: cir.store{{.*}} %[[THIRTY]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
@@ -201,8 +201,8 @@ const int &test_cond_const_true_throw_true() {
}
// CIR-LABEL: cir.func{{.*}} @_Z31test_cond_const_true_throw_truev(
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["__retval"]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init, const]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_30:.*]] = cir.const #cir.int<30> : !s32i
// CIR: cir.store{{.*}} %[[CONST_30]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[EXCEPTION:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i>
@@ -245,9 +245,9 @@ int test_agg_cond_throw_false(bool flag, struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z25test_agg_cond_throw_falseb2s6S_(
-// CIR: %[[FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["flag", init]
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1", init]
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2", init]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[COND_RES:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: cir.yield %[[A1]] : !cir.ptr<!rec_s6>
@@ -310,9 +310,9 @@ int test_agg_cond_throw_true(bool flag, struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z24test_agg_cond_throw_trueb2s6S_(
-// CIR: %[[FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["flag", init]
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1", init]
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2", init]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[COND_RES:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: %[[EXC:.*]] = cir.alloc.exception{{.*}} -> !cir.ptr<!s32i>
@@ -375,8 +375,8 @@ const int test_agg_cond_const_true_throw_false(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z36test_agg_cond_const_true_throw_false2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1", init]
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2", init]
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR-NOT: cir.ternary
// CIR-NOT: cir.throw
// CIR: %[[F0:.*]] = cir.get_member %[[A1]][0] {name = "f0"} : !cir.ptr<!rec_s6> -> !cir.ptr<!s32i>
@@ -411,8 +411,8 @@ const int test_agg_cond_const_true_throw_true(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z35test_agg_cond_const_true_throw_true2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1", init]
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2", init]
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: %[[EXC:.*]] = cir.alloc.exception{{.*}} -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[EXC]] : !s32i, !cir.ptr<!s32i>
@@ -451,8 +451,8 @@ const int test_agg_cond_const_false_throw_false(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z37test_agg_cond_const_false_throw_false2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1", init]
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2", init]
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR: %[[EXC:.*]] = cir.alloc.exception{{.*}} -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[EXC]] : !s32i, !cir.ptr<!s32i>
@@ -491,8 +491,8 @@ const int test_agg_cond_const_false_throw_true(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z36test_agg_cond_const_false_throw_true2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a1", init]
-// CIR: %[[A2:.*]] = cir.alloca !rec_s6, !cir.ptr<!rec_s6>, ["a2", init]
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
// CIR-NOT: cir.ternary
// CIR-NOT: cir.throw
// CIR: %[[F0:.*]] = cir.get_member %[[A1]][0] {name = "f0"} : !cir.ptr<!rec_s6> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/ternary.cpp b/clang/test/CIR/CodeGen/ternary.cpp
index c3b8d86af2cd0..8d6823048dc4c 100644
--- a/clang/test/CIR/CodeGen/ternary.cpp
+++ b/clang/test/CIR/CodeGen/ternary.cpp
@@ -11,8 +11,8 @@ int x(int y) {
// CIR-LABEL: cir.func{{.*}} @_Z1xi(
// CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}) -> (!s32i{{.*}}) attributes {{{.*}}nothrow} {
-// CIR: [[Y:%.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init]
-// CIR: [[RETVAL:%.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: [[Y:%.+]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], [[Y]] : !s32i, !cir.ptr<!s32i>
// CIR: [[YVAL:%.+]] = cir.load{{.*}} [[Y]] : !cir.ptr<!s32i>, !s32i
// CIR: [[ZERO:%.+]] = cir.const #cir.int<0> : !s32i
@@ -53,9 +53,9 @@ int foo(int a, int b) {
// CIR-LABEL: cir.func{{.*}} @_Z3fooii(
// CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}, %[[ARG1:.*]]: !s32i {{.*}}) -> (!s32i{{.*}}) attributes {{{.*}}nothrow} {
-// CIR: [[A:%.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: [[B:%.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: [[RETVAL:%.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: [[A:%.+]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[B:%.+]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], [[A]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %[[ARG1]], [[B]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
@@ -152,9 +152,9 @@ void test_cond_lvalue_assign(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z23test_cond_lvalue_assignb(
-// CIR: %[[FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["flag", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]]
// CIR: %[[TERNARY_PTR:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: cir.yield %[[A]] : !cir.ptr<!s32i>
@@ -200,9 +200,9 @@ int& test_cond_lvalue_ref(bool cond, int x, int y) {
}
// CIR-LABEL: cir.func{{.*}} @_Z20test_cond_lvalue_refbii(
-// CIR: %[[COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cond", init]
-// CIR: %[[X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[Y:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init]
+// CIR: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[COND_VAL:.*]] = cir.load{{.*}} %[[COND]]
// CIR: %[[REF_PTR:.*]] = cir.ternary(%[[COND_VAL]], true {
// CIR: cir.yield %[[X]] : !cir.ptr<!s32i>
@@ -255,9 +255,9 @@ void test_cond_lvalue_compound(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z25test_cond_lvalue_compoundb(
-// CIR: %[[FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["flag", init]
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]]
// CIR: %[[LVAL_PTR:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: cir.yield %[[A]] : !cir.ptr<!s32i>
@@ -312,8 +312,8 @@ void test_cond_const_true_lvalue() {
}
// CIR-LABEL: cir.func{{.*}} @_Z27test_cond_const_true_lvaluev(
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
// CIR: %[[NINETYNINE:.*]] = cir.const #cir.int<99> : !s32i
// CIR: cir.store{{.*}} %[[NINETYNINE]], %[[A]] : !s32i, !cir.ptr<!s32i>
@@ -338,8 +338,8 @@ void test_cond_const_false_lvalue() {
}
// CIR-LABEL: cir.func{{.*}} @_Z28test_cond_const_false_lvaluev(
-// CIR: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
// CIR: %[[EIGHTYEIGHT:.*]] = cir.const #cir.int<88> : !s32i
// CIR: cir.store{{.*}} %[[EIGHTYEIGHT]], %[[B]] : !s32i, !cir.ptr<!s32i>
@@ -362,7 +362,7 @@ void ternary_void(bool b) {
}
// CIR-LABEL: cir.func{{.*}}@_Z12ternary_voidb
-// CIR: %[[ARG:.*]] = cir.alloca !cir.bool
+// CIR: %[[ARG:.*]] = cir.alloca {{.*}} !cir.bool
// CIR: %[[LOAD_ARG:.*]] = cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.bool>
// CIR: cir.ternary(%[[LOAD_ARG]], true {
// CIR-NEXT: cir.call @_Z3foov()
diff --git a/clang/test/CIR/CodeGen/thread-local-in-func.cpp b/clang/test/CIR/CodeGen/thread-local-in-func.cpp
index fb8231675e371..23bb1d9fae100 100644
--- a/clang/test/CIR/CodeGen/thread-local-in-func.cpp
+++ b/clang/test/CIR/CodeGen/thread-local-in-func.cpp
@@ -39,8 +39,8 @@ void test_int(int param) {
thread_local int init = param + local + get_i();
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z8test_inti(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["param", init]
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["local"]
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_CONST_TLS:.*]] = cir.get_global thread_local @_ZZ8test_intiE10const_init : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_TLS:.*]] = cir.get_global thread_local static_local @_ZZ8test_intiE4init : !cir.ptr<!s32i>
//
@@ -103,8 +103,8 @@ void test_ctor(int param) {
thread_local Ctor const_init = 5;
thread_local Ctor init = param + local + get_i();
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z9test_ctori(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["param", init]
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["local"]
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_CONST_TLS:.*]] = cir.get_global thread_local static_local @_ZZ9test_ctoriE10const_init : !cir.ptr<!rec_Ctor>
//
// CIR-BEFORE-LPP: cir.local_init thread_local @_ZZ9test_ctoriE10const_init ctor {
@@ -193,8 +193,8 @@ void test_dtor(int param) {
int local;
thread_local Dtor const_init;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z9test_dtori(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["param", init]
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["local"]
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_TLS:.*]] = cir.get_global thread_local static_local @_ZZ9test_dtoriE10const_init : !cir.ptr<!rec_Dtor>
//
// CIR-BEFORE-LPP: cir.local_init thread_local @_ZZ9test_dtoriE10const_init dtor {
@@ -246,8 +246,8 @@ void test_ctordtor(int param) {
thread_local CtorDtor const_init = 5;
thread_local CtorDtor init = param + local + get_i();
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z13test_ctordtori(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["param", init]
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["local"]
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_CONST_TLS:.*]] = cir.get_global thread_local static_local @_ZZ13test_ctordtoriE10const_init : !cir.ptr<!rec_CtorDtor>
// CIR-BEFORE-LLP: cir.local_init thread_local @_ZZ13test_ctordtoriE10const_init ctor {
// CIR-BEFORE-LPP: %[[GET_CONST_TLS_INIT:.*]] = cir.get_global thread_local static_local @_ZZ13test_ctordtoriE10const_init : !cir.ptr<!rec_CtorDtor>
diff --git a/clang/test/CIR/CodeGen/three-way-cmp.cpp b/clang/test/CIR/CodeGen/three-way-cmp.cpp
index 10b729fb16bfd..00926f940627c 100644
--- a/clang/test/CIR/CodeGen/three-way-cmp.cpp
+++ b/clang/test/CIR/CodeGen/three-way-cmp.cpp
@@ -106,13 +106,13 @@ struct HasMember {
void use_pseudo_ordering(HasMember m1, HasMember m2) {
// BOTH: cir.func {{.*}}@_ZNK9HasMemberssERKS_(%{{.*}}: !cir.ptr<!rec_HasMember>{{.*}}, %{{.*}}: !cir.ptr<!rec_HasMember>{{.*}}) -> !rec_std3A3A__13A3Astrong_ordering
- // BOTH: %[[LHS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasMember>, !cir.ptr<!cir.ptr<!rec_HasMember>>, ["this", init]
- // BOTH: %[[RHS_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasMember>, !cir.ptr<!cir.ptr<!rec_HasMember>>, ["", init, const]
- // BOTH: %[[RET_ALLOCA:.*]] = cir.alloca !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>, ["__retval"]
+ // BOTH: %[[LHS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasMember> -> !cir.ptr<!cir.ptr<!rec_HasMember>>
+ // BOTH: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_HasMember> -> !cir.ptr<!cir.ptr<!rec_HasMember>>
+ // BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: %[[LHS_LOAD:.*]] = cir.load deref %[[LHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMember>>, !cir.ptr<!rec_HasMember>
// BOTH: cir.scope {
- // BOTH: %[[CMP_RES:.*]] = cir.alloca !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>, ["cmp", init]
- // BOTH: %[[CMP_TEMP:.*]] = cir.alloca !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>, ["agg.tmp0"]
+ // BOTH: %[[CMP_RES:.*]] = cir.alloca "cmp" {{.*}} init !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
+ // BOTH: %[[CMP_TEMP:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: %[[LHS_MEMBER:.*]] = cir.cast bitcast %[[LHS_LOAD]] : !cir.ptr<!rec_HasMember> -> !cir.ptr<!rec_Member>
// BOTH: %[[RHS_LOAD:.*]] = cir.load %[[RHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMember>>, !cir.ptr<!rec_HasMember>
// BOTH: %[[RHS_MEMBER:.*]] = cir.cast bitcast %[[RHS_LOAD]] : !cir.ptr<!rec_HasMember> -> !cir.ptr<!rec_Member>
@@ -148,9 +148,9 @@ void use_pseudo_ordering(HasMember m1, HasMember m2) {
// BOTH: cir.return %[[RET_LOAD]] : !rec_std3A3A__13A3Astrong_ordering
// BOTH: cir.func {{.*}} @_Z19use_pseudo_ordering9HasMemberS_(%[[M1:.*]]: !rec_HasMember{{.*}}, %[[M2:.*]]: !rec_HasMember{{.*}})
- // BOTH: %[[M1_ALLOCA:.*]] = cir.alloca !rec_HasMember, !cir.ptr<!rec_HasMember>, ["m1", init]
- // BOTH: %[[M2_ALLOCA:.*]] = cir.alloca !rec_HasMember, !cir.ptr<!rec_HasMember>, ["m2", init] {alignment = 1 : i64}
- // BOTH: %[[G_ALLOCA:.*]] = cir.alloca !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>, ["g", init]
+ // BOTH: %[[M1_ALLOCA:.*]] = cir.alloca "m1" {{.*}} init !rec_HasMember -> !cir.ptr<!rec_HasMember>
+ // BOTH: %[[M2_ALLOCA:.*]] = cir.alloca "m2" align(1) init !rec_HasMember -> !cir.ptr<!rec_HasMember>
+ // BOTH: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: %[[CALL_RES:.*]] = cir.call @_ZNK9HasMemberssERKS_(%[[M1_ALLOCA]], %[[M2_ALLOCA]]) : (!cir.ptr<!rec_HasMember> {{.*}}, !cir.ptr<!rec_HasMember> {{.*}}) -> !rec_std3A3A__13A3Astrong_ordering
// BOTH: cir.store {{.*}}%[[CALL_RES]], %[[G_ALLOCA]] : !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
std::strong_ordering g = (m1 <=> m2);
diff --git a/clang/test/CIR/CodeGen/throws.cpp b/clang/test/CIR/CodeGen/throws.cpp
index 8b415f386c00e..cafbbe6527ca9 100644
--- a/clang/test/CIR/CodeGen/throws.cpp
+++ b/clang/test/CIR/CodeGen/throws.cpp
@@ -24,9 +24,9 @@ int rethrow_from_block(int a, int b) {
return a / b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CIR: %[[RES_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %{{.*}}, %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
@@ -149,7 +149,7 @@ void throw_vector_type() {
throw a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 16 -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[EXCEPTION_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -175,7 +175,7 @@ void throw_ext_vector_type() {
throw a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 16 -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[EXCEPTION_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -249,7 +249,7 @@ void throw_pointer_type() {
throw ptr;
}
-// CIR: %[[PTR_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["ptr", init]
+// CIR: %[[PTR_ADDR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[VAR_ADDR:.*]] = cir.get_global @_ZZ18throw_pointer_typevE3var : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[VAR_ADDR]], %[[PTR_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 8 -> !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGen/thunks.cpp b/clang/test/CIR/CodeGen/thunks.cpp
index 20b25b1599aac..dfdc1225cc020 100644
--- a/clang/test/CIR/CodeGen/thunks.cpp
+++ b/clang/test/CIR/CodeGen/thunks.cpp
@@ -184,7 +184,7 @@ void C::f(int x, ...) {}
// The thunk adjusts 'this' by -8 bytes and calls C::f().
// CIR: cir.func {{.*}} @_ZThn8_N5Test11C1fEv(%arg0: !cir.ptr<
-// CIR: %[[T1_THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CIR: %[[T1_THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CIR: cir.store %arg0, %[[T1_THIS_ADDR]]
// CIR: %[[T1_THIS:.*]] = cir.load %[[T1_THIS_ADDR]]
// CIR: %[[T1_CAST:.*]] = cir.cast bitcast %[[T1_THIS]] : !cir.ptr<{{.*}}> -> !cir.ptr<!u8i>
@@ -251,8 +251,8 @@ void C::f(int x, ...) {}
// CIR: cir.func {{.*}} @_ZN5Test51C1hEv
// CIR: cir.func {{.*}} @_ZThn8_N5Test51C1hEv(%arg0: !cir.ptr<
-// CIR: %[[T5_THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR: %[[T5_RETVAL:.*]] = cir.alloca !rec_Test5{{.*}}NonTrivial, {{.*}} ["__retval"]
+// CIR: %[[T5_THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR: %[[T5_RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_Test5{{.*}}NonTrivial
// CIR: cir.store %arg0, %[[T5_THIS_ADDR]]
// CIR: %[[T5_THIS:.*]] = cir.load %[[T5_THIS_ADDR]]
// CIR: %[[T5_CAST:.*]] = cir.cast bitcast %[[T5_THIS]] : !cir.ptr<{{.*}}> -> !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp b/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp
index 8d75f041fc22b..eef02a3f8fe1a 100644
--- a/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp
+++ b/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp
@@ -27,7 +27,7 @@ StructWithCtorArg withArg = 0.0;
// OGCG: @withArg = global %struct.StructWithCtorArg zeroinitializer
// CIR: cir.func {{.*}} @__cxx_global_var_init()
-// CIR: %[[TMP0:.*]] = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["ref.tmp0"]
+// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.double -> !cir.ptr<!cir.double>
// CIR: %[[WITH_ARG:.*]] = cir.get_global @withArg : !cir.ptr<!rec_StructWithCtorArg>
// CIR: %[[ZERO:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.double
// CIR: cir.store{{.*}} %[[ZERO]], %[[TMP0]] : !cir.double, !cir.ptr<!cir.double>
diff --git a/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp b/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp
index 6594165b823cb..ac0f35c8eb42e 100644
--- a/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp
@@ -24,7 +24,7 @@ void test_catch_all_with_cleanup() {
// CIR-LABEL: cir.func {{.*}} @_Z27test_catch_all_with_cleanupv()
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.try {
// CIR: cir.call @_ZN1SC1Ev(%[[S]])
// CIR: cir.cleanup.scope {
@@ -49,7 +49,7 @@ void test_catch_all_with_cleanup() {
// CIR-FLAT-LABEL: cir.func {{.*}} @_Z27test_catch_all_with_cleanupv()
//
-// CIR-FLAT: %[[S:.*]] = cir.alloca !rec_S
+// CIR-FLAT: %[[S:.*]] = cir.alloca {{.*}} !rec_S
//
// Ctor may throw; unwinds directly to the dispatch (no cleanup needed yet).
// CIR-FLAT: cir.try_call @_ZN1SC1Ev(%[[S]]) ^[[AFTER_CTOR:bb[0-9]+]], ^[[CTOR_UNWIND:bb[0-9]+]]
@@ -148,8 +148,8 @@ void test_catch_all_and_specific_with_cleanup() {
// CIR-LABEL: cir.func {{.*}} @_Z40test_catch_all_and_specific_with_cleanupv()
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s", init]
-// CIR: %[[E:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e"]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: cir.call @_ZN1SC1Ev(%[[S]])
// CIR: cir.cleanup.scope {
@@ -184,7 +184,7 @@ void test_catch_all_and_specific_with_cleanup() {
// CIR-FLAT-LABEL: cir.func {{.*}} @_Z40test_catch_all_and_specific_with_cleanupv()
//
-// CIR-FLAT: %[[S:.*]] = cir.alloca !rec_S
+// CIR-FLAT: %[[S:.*]] = cir.alloca {{.*}} !rec_S
//
// Ctor may throw; unwinds directly to the dispatch (no cleanup needed yet).
// CIR-FLAT: cir.try_call @_ZN1SC1Ev(%[[S]]) ^[[AFTER_CTOR:bb[0-9]+]], ^[[CTOR_UNWIND:bb[0-9]+]]
diff --git a/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp b/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp
index af458bdb0f73d..faa6f803fbec2 100644
--- a/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp
+++ b/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp
@@ -42,10 +42,10 @@ int test_non_trivial_exception_copy() {
// it later.
// CIR-LABEL: cir.func {{.*}} @_Z31test_non_trivial_exception_copyv()
-// CIR: %[[RETVAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[RV:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["rv", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RV:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[E:.*]] = cir.alloca !rec_MyException, !cir.ptr<!rec_MyException>, ["e"]
+// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} !rec_MyException -> !cir.ptr<!rec_MyException>
// CIR: cir.try {
// CIR: cir.call @_Z8mayThrowv() : () -> ()
// CIR: } catch [type #cir.global_view<@_ZTI11MyException> : !cir.ptr<!u8i>] (%[[EH_TOKEN:.*]]: !cir.eh_token {{.*}}) {
@@ -357,7 +357,7 @@ int test_copy_ctor_extra_args() {
// exact switch shape here, but we do verify the EH-relevant control flow.
// CIR-FLAT-LABEL: cir.func {{.*}} @_Z25test_copy_ctor_extra_argsv()
-// CIR-FLAT: %{{.*}} = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
+// CIR-FLAT: %{{.*}} = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
// CIR-FLAT: cir.try_call @_Z8mayThrowv() ^[[T2F_CONT:bb[0-9]+]], ^[[T2F_LPAD:bb[0-9]+]]
// CIR-FLAT: ^[[T2F_LPAD]]:
diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp
index cf971062437a6..94b2dd2e67ad4 100644
--- a/clang/test/CIR/CodeGen/try-catch.cpp
+++ b/clang/test/CIR/CodeGen/try-catch.cpp
@@ -40,7 +40,7 @@ void try_catch_with_empty_catch_all() {
}
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i
// CIR: cir.scope {
@@ -84,7 +84,7 @@ void try_catch_with_empty_catch_all_2() {
}
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
@@ -129,9 +129,9 @@ void try_catch_with_alloca() {
// CIR: cir.func {{.*}} @_Z21try_catch_with_allocav() personality(@__gxx_personality_v0)
// CIR: cir.scope {
-// CIR: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!s32i>, !s32i
@@ -886,7 +886,7 @@ void cleanup_inside_try_body() {
// CIR: cir.func {{.*}} @_Z23cleanup_inside_try_bodyv(){{.*}} personality(@__gxx_personality_v0){{.*}} {
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["s"]
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.try {
// CIR: cir.cleanup.scope {
// CIR: cir.call @_Z8divisionv()
@@ -1113,7 +1113,7 @@ void call_function_inside_try_catch_with_ref_ptr_of_record_exception_type() {
}
// CIR: cir.func {{.*}} @_Z68call_function_inside_try_catch_with_ref_ptr_of_record_exception_typev(){{.*}} personality(@__gxx_personality_v0){{.*}} {
-// CIR: %[[E_ADDR:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_Record>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_Record>>>, ["ref_ptr", const]
+// CIR: %[[E_ADDR:.*]] = cir.alloca "ref_ptr" {{.*}} const !cir.ptr<!cir.ptr<!rec_Record>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_Record>>>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1345,10 +1345,10 @@ int init_catch_param_with_type_int() {
}
// CIR: cir.func {{.*}} @_Z30init_catch_param_with_type_intv() {{.*}} personality(@__gxx_personality_v0)
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[RV_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["rv", init]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1486,10 +1486,10 @@ int init_catch_param_with_type_int_ptr() {
}
// CIR: cir.func {{.*}} @_Z34init_catch_param_with_type_int_ptrv() {{.*}} personality(@__gxx_personality_v0)
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[RV_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["rv", init]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[X_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["x"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1627,10 +1627,10 @@ int init_catch_param_with_ref_to_ptr_to_non_record() {
}
// CIR: cir.func {{.*}} @_Z46init_catch_param_with_ref_to_ptr_to_non_recordv() {{.*}} personality(@__gxx_personality_v0)
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[RV_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["rv", init]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[P_ADDR:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["p", const]
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} const !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
diff --git a/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp b/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp
index c21b25163c2c5..91b5c36d556bd 100644
--- a/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp
+++ b/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp
@@ -24,7 +24,7 @@ int test() {
// Verify the try body (call + store) is preserved, not discarded.
// CIR: cir.func {{.*}} @_Z4testv
-// CIR: %[[RESULT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["result", init]
+// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[CALL:.*]] = cir.call @_Z11nonThrowingv()
// CIR: cir.store {{.*}}%[[CALL]], %[[RESULT]]
diff --git a/clang/test/CIR/CodeGen/typedef.c b/clang/test/CIR/CodeGen/typedef.c
index 201df2e08ee2e..d85fc24a192e9 100644
--- a/clang/test/CIR/CodeGen/typedef.c
+++ b/clang/test/CIR/CodeGen/typedef.c
@@ -11,7 +11,7 @@ void local_typedef(void) {
}
// CIR: cir.func{{.*}} @local_typedef()
-// CIR: cir.alloca !rec_Struct, !cir.ptr<!rec_Struct>, ["s"] {alignment = 4 : i64}
+// CIR: cir.alloca "s" align(4) !rec_Struct -> !cir.ptr<!rec_Struct>
// CIR: cir.return
// LLVM: %struct.Struct = type { i32 }
diff --git a/clang/test/CIR/CodeGen/unary.cpp b/clang/test/CIR/CodeGen/unary.cpp
index 2af96583fe34b..52652cd950d06 100644
--- a/clang/test/CIR/CodeGen/unary.cpp
+++ b/clang/test/CIR/CodeGen/unary.cpp
@@ -11,7 +11,7 @@ unsigned up0() {
}
// CHECK: cir.func{{.*}} @_Z3up0v() -> (!u32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// LLVM: define{{.*}} i32 @_Z3up0v()
@@ -31,7 +31,7 @@ unsigned um0() {
}
// CHECK: cir.func{{.*}} @_Z3um0v() -> (!u32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// CHECK: %[[OUTPUT:.*]] = cir.minus %[[INPUT]]
@@ -54,7 +54,7 @@ unsigned un0() {
}
// CHECK: cir.func{{.*}} @_Z3un0v() -> (!u32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// CHECK: %[[OUTPUT:.*]] = cir.not %[[INPUT]]
@@ -78,7 +78,7 @@ int inc0() {
}
// CHECK: cir.func{{.*}} @_Z4inc0v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -106,7 +106,7 @@ int dec0() {
}
// CHECK: cir.func{{.*}} @_Z4dec0v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -134,7 +134,7 @@ int inc1() {
}
// CHECK: cir.func{{.*}} @_Z4inc1v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -162,7 +162,7 @@ int dec1() {
}
// CHECK: cir.func{{.*}} @_Z4dec1v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -191,8 +191,8 @@ int inc2() {
}
// CHECK: cir.func{{.*}} @_Z4inc2v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CHECK: %[[B:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[ATOB:.*]] = cir.load{{.*}} %[[A]]
@@ -228,7 +228,7 @@ float fpPlus() {
}
// CHECK: cir.func{{.*}} @_Z6fpPlusv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// LLVM: define{{.*}} float @_Z6fpPlusv()
@@ -248,7 +248,7 @@ float fpMinus() {
}
// CHECK: cir.func{{.*}} @_Z7fpMinusv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// CHECK: %[[OUTPUT:.*]] = cir.minus %[[INPUT]]
@@ -271,7 +271,7 @@ float fpPreInc() {
}
// CHECK: cir.func{{.*}} @_Z8fpPreIncv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -296,7 +296,7 @@ float fpPreDec() {
}
// CHECK: cir.func{{.*}} @_Z8fpPreDecv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -321,7 +321,7 @@ float fpPostInc() {
}
// CHECK: cir.func{{.*}} @_Z9fpPostIncv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -346,7 +346,7 @@ float fpPostDec() {
}
// CHECK: cir.func{{.*}} @_Z9fpPostDecv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -373,8 +373,8 @@ float fpPostInc2() {
}
// CHECK: cir.func{{.*}} @_Z10fpPostInc2v() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init]
-// CHECK: %[[B:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[ATOB:.*]] = cir.load{{.*}} %[[A]]
@@ -559,8 +559,8 @@ void f16NestedUPlus() {
}
// CHECK: cir.func{{.*}} @_Z14f16NestedUPlusv()
-// CHECK: %[[A_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["a"]
-// CHECK: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
+// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// CHECK: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CHECK: %[[A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
// CHECK: %[[RESULT:.*]] = cir.cast floating %[[A_F32]] : !cir.float -> !cir.f16
@@ -588,8 +588,8 @@ void f16NestedUMinus() {
}
// CHECK: cir.func{{.*}} @_Z15f16NestedUMinusv()
-// CHECK: %[[A_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["a"]
-// CHECK: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
+// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
// CHECK: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CHECK: %[[A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
// CHECK: %[[A_MINUS:.*]] = cir.minus %[[A_F32]] : !cir.float
diff --git a/clang/test/CIR/CodeGen/union-agg-init.c b/clang/test/CIR/CodeGen/union-agg-init.c
index caabc4c7e738f..8b4523a8d9877 100644
--- a/clang/test/CIR/CodeGen/union-agg-init.c
+++ b/clang/test/CIR/CodeGen/union-agg-init.c
@@ -15,7 +15,7 @@ typedef union vec3 {
// In C mode, this does do zero padding.
vec3 ret_vec3() {
// CIR-LABEL: ret_vec3
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !rec_vec3, !cir.ptr<!rec_vec3>, ["__retval"]
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_vec3 -> !cir.ptr<!rec_vec3>
// CIR: %[[GET_ANON:.*]] = cir.get_member %[[RET_ALLOCA]][0] {name = ""}
// CIR: %[[GET_X:.*]] = cir.get_member %[[GET_ANON]][0] {name = "x"}
// CIR: %[[FIVE:.*]] = cir.const #cir.fp<5.{{.*}}> : !cir.double
@@ -53,7 +53,7 @@ struct outer ret_outer() {
return o;
// CIR-LABEL: ret_outer
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !rec_outer, !cir.ptr<!rec_outer>, ["__retval", init]
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} init !rec_outer -> !cir.ptr<!rec_outer>
// CIR: %[[BITCAST:.*]] = cir.cast bitcast %0 : !cir.ptr<!rec_outer> -> !cir.ptr<!{{.*}}>
// CIR: %[[RECORD:.*]] = cir.const #cir.const_record<{#cir.zero : !{{.*}}, #cir.int<1> : !s32i, #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 4>}>
// CIR: cir.store {{.*}}%[[RECORD]], %[[BITCAST]]
diff --git a/clang/test/CIR/CodeGen/union-agg-init.cpp b/clang/test/CIR/CodeGen/union-agg-init.cpp
index e83a9ea017772..0a9219859dab6 100644
--- a/clang/test/CIR/CodeGen/union-agg-init.cpp
+++ b/clang/test/CIR/CodeGen/union-agg-init.cpp
@@ -13,7 +13,7 @@ typedef union vec3 {
// In C++ mode, this doesn't do zero padding.
extern "C" vec3 ret_vec3() {
// CIR-LABEL: ret_vec3
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !rec_vec3, !cir.ptr<!rec_vec3>, ["__retval"]
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_vec3 -> !cir.ptr<!rec_vec3>
// CIR: %[[GET_ANON:.*]] = cir.get_member %[[RET_ALLOCA]][0] {name = ""}
// CIR: %[[GET_X:.*]] = cir.get_member %[[GET_ANON]][0] {name = "x"}
// CIR: %[[FIVE:.*]] = cir.const #cir.fp<5.{{.*}}> : !cir.double
@@ -43,7 +43,7 @@ typedef union Trivial {
extern "C" Trivial ret_trivial() { return {}; }
// CIR-LABEL: ret_trivial
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca !rec_Trivial, !cir.ptr<!rec_Trivial>, ["__retval"]
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_Trivial -> !cir.ptr<!rec_Trivial>
// CIR: %[[GET_A:.*]] = cir.get_member %[[RET_ALLOCA]][0] {name = "a"}
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0>
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]]
diff --git a/clang/test/CIR/CodeGen/union.c b/clang/test/CIR/CodeGen/union.c
index 29728ceecd448..d6057b696b400 100644
--- a/clang/test/CIR/CodeGen/union.c
+++ b/clang/test/CIR/CodeGen/union.c
@@ -55,7 +55,7 @@ void f1(void) {
}
// CIR: cir.func{{.*}} @f1()
-// CIR-NEXT: cir.alloca !cir.ptr<!rec_IncompleteU>, !cir.ptr<!cir.ptr<!rec_IncompleteU>>, ["p"]
+// CIR-NEXT: cir.alloca "p" {{.*}} !cir.ptr<!rec_IncompleteU> -> !cir.ptr<!cir.ptr<!rec_IncompleteU>>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @f1()
@@ -74,8 +74,8 @@ int f2(void) {
}
// CIR: cir.func{{.*}} @f2() -> !s32i
-// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CIR-NEXT: %[[U:.*]] = cir.alloca !rec_U1, !cir.ptr<!rec_U1>, ["u"] {alignment = 4 : i64}
+// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) !rec_U1 -> !cir.ptr<!rec_U1>
// CIR-NEXT: %[[I:.*]] = cir.const #cir.int<42> : !s32i
// CIR-NEXT: %[[N:.*]] = cir.get_member %[[U]][0] {name = "n"} : !cir.ptr<!rec_U1> -> !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[I]], %[[N]] : !s32i, !cir.ptr<!s32i>
@@ -113,7 +113,7 @@ void shouldGenerateUnionAccess(union U2 u) {
}
// CIR: cir.func{{.*}} @shouldGenerateUnionAccess(%[[ARG:.*]]: !rec_U2
-// CIR-NEXT: %[[U:.*]] = cir.alloca !rec_U2, !cir.ptr<!rec_U2>, ["u", init] {alignment = 8 : i64}
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(8) init !rec_U2 -> !cir.ptr<!rec_U2>
// CIR-NEXT: cir.store{{.*}} %[[ARG]], %[[U]] : !rec_U2, !cir.ptr<!rec_U2>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s8i
// CIR-NEXT: %[[B_PTR:.*]] = cir.get_member %[[U]][0] {name = "b"} : !cir.ptr<!rec_U2> -> !cir.ptr<!s8i>
@@ -170,7 +170,7 @@ void f3(union U3 u) {
}
// CIR: cir.func{{.*}} @f3(%[[ARG:.*]]: !rec_U3
-// CIR-NEXT: %[[U:.*]] = cir.alloca !rec_U3, !cir.ptr<!rec_U3>, ["u", init] {alignment = 1 : i64}
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(1) init !rec_U3 -> !cir.ptr<!rec_U3>
// CIR-NEXT: cir.store{{.*}} %[[ARG]], %[[U]] : !rec_U3, !cir.ptr<!rec_U3>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s8i
// CIR-NEXT: %[[IDX:.*]] = cir.const #cir.int<2> : !s64i
@@ -199,7 +199,7 @@ void f5(union U4 u) {
}
// CIR: cir.func{{.*}} @f5(%[[ARG:.*]]: !rec_U4
-// CIR-NEXT: %[[U:.*]] = cir.alloca !rec_U4, !cir.ptr<!rec_U4>, ["u", init] {alignment = 4 : i64}
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init !rec_U4 -> !cir.ptr<!rec_U4>
// CIR-NEXT: cir.store{{.*}} %[[ARG]], %[[U]] : !rec_U4, !cir.ptr<!rec_U4>
// CIR-NEXT: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
// CIR-NEXT: %[[IDX:.*]] = cir.const #cir.int<4> : !s64i
diff --git a/clang/test/CIR/CodeGen/var-arg-aggregate.c b/clang/test/CIR/CodeGen/var-arg-aggregate.c
index 78958576d02b6..10a2337900d51 100644
--- a/clang/test/CIR/CodeGen/var-arg-aggregate.c
+++ b/clang/test/CIR/CodeGen/var-arg-aggregate.c
@@ -20,9 +20,9 @@ struct Bar varargs_aggregate(int count, ...) {
}
// CIR-LABEL: cir.func {{.*}} @varargs_aggregate(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca !rec_Bar, !cir.ptr<!rec_Bar>, ["__retval", init]
-// CIR: %[[VAAREA:.+]] = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["args"]
-// CIR: %[[TMP_ADDR:.+]] = cir.alloca !rec_Bar, !cir.ptr<!rec_Bar>, ["vaarg.tmp"]
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} init !rec_Bar -> !cir.ptr<!rec_Bar>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[TMP_ADDR:.+]] = cir.alloca "vaarg.tmp" {{.*}} !rec_Bar -> !cir.ptr<!rec_Bar>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
diff --git a/clang/test/CIR/CodeGen/var_arg.c b/clang/test/CIR/CodeGen/var_arg.c
index fe9f7042ad308..64f0464d93e13 100644
--- a/clang/test/CIR/CodeGen/var_arg.c
+++ b/clang/test/CIR/CodeGen/var_arg.c
@@ -18,9 +18,9 @@ int varargs(int count, ...) {
}
// CIR-LABEL: cir.func {{.*}} @varargs(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[VAAREA:.+]] = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["args"]
-// CIR: %[[RES_ADDR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["res", init]
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
@@ -91,9 +91,9 @@ int stdarg_start(int count, ...) {
}
// CIR-LABEL: cir.func {{.*}} @stdarg_start(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[VAAREA:.+]] = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["args"]
-// CIR: %[[RES_ADDR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["res", init]
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
@@ -189,9 +189,9 @@ int varargs_new(char *fmt, ...) {
}
// CIR-LABEL: cir.func {{.*}} @varargs_new(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[VAAREA:.+]] = cir.alloca !cir.array<!rec___va_list_tag x 1>, !cir.ptr<!cir.array<!rec___va_list_tag x 1>>, ["args"]
-// CIR: %[[RES_ADDR:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["res", init]
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
diff --git a/clang/test/CIR/CodeGen/variable-decomposition.cpp b/clang/test/CIR/CodeGen/variable-decomposition.cpp
index 569f36bf753de..4619167fff1f0 100644
--- a/clang/test/CIR/CodeGen/variable-decomposition.cpp
+++ b/clang/test/CIR/CodeGen/variable-decomposition.cpp
@@ -20,8 +20,8 @@ float function() {
// LLVM-DAG: @[[FUNC_CONST:.*]] = private constant %struct.some_struct { i32 1, float 2.000000e+00 }
// CIR-LABEL: cir.func {{.*}} @_Z8functionv() -> (!cir.float {llvm.noundef})
-// CIR: %[[RETVAL:.+]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["__retval"]
-// CIR: %[[STRUCT:.+]] = cir.alloca !rec_some_struct, !cir.ptr<!rec_some_struct>, ["", init]
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[STRUCT:.+]] = cir.alloca "" {{.*}} init !rec_some_struct -> !cir.ptr<!rec_some_struct>
// CIR: %[[CONST:.+]] = cir.get_global @[[FUNC_CONST]] : !cir.ptr<!rec_some_struct>
// CIR: cir.copy %[[CONST]] to %[[STRUCT]]
// CIR: %[[MEMBER_A:.+]] = cir.get_member %[[STRUCT]][0] {name = "a"} : !cir.ptr<!rec_some_struct> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/vbase.cpp b/clang/test/CIR/CodeGen/vbase.cpp
index 56336b9de5b31..27f711179ed3b 100644
--- a/clang/test/CIR/CodeGen/vbase.cpp
+++ b/clang/test/CIR/CodeGen/vbase.cpp
@@ -57,7 +57,7 @@ void ppp() { B b; }
// OGCG: @_ZTV1B = linkonce_odr constant { [3 x ptr] } { [3 x ptr] [ptr inttoptr (i64 12 to ptr), ptr null, ptr @_ZTI1B] }, comdat, align 8
// CIR: cir.func {{.*}}@_Z1fv()
-// CIR: %[[D:.+]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["d", init]
+// CIR: %[[D:.+]] = cir.alloca "d" {{.*}} init !rec_Derived -> !cir.ptr<!rec_Derived>
// CIR: cir.call @_ZN7DerivedC1Ev(%[[D]]) nothrow : (!cir.ptr<!rec_Derived> {{.*}}) -> ()
// CIR: %[[VPTR_PTR:.+]] = cir.vtable.get_vptr %[[D]] : !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.vptr>
// CIR: %[[VPTR:.+]] = cir.load {{.*}} %[[VPTR_PTR]] : !cir.ptr<!cir.vptr>, !cir.vptr
@@ -74,7 +74,7 @@ void ppp() { B b; }
// CIR: cir.return
// CIR: cir.func {{.*}}@_Z1gv()
-// CIR: %[[DF:.+]] = cir.alloca !rec_DerivedFinal, !cir.ptr<!rec_DerivedFinal>, ["df", init]
+// CIR: %[[DF:.+]] = cir.alloca "df" {{.*}} init !rec_DerivedFinal -> !cir.ptr<!rec_DerivedFinal>
// CIR: cir.call @_ZN12DerivedFinalC1Ev(%[[DF]]) nothrow : (!cir.ptr<!rec_DerivedFinal> {{.*}}) -> ()
// CIR: %[[BASE_THIS_2:.+]] = cir.base_class_addr %[[DF]] : !cir.ptr<!rec_DerivedFinal> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: cir.call @_ZN4Base1fEv(%[[BASE_THIS_2]]) : (!cir.ptr<!rec_Base> {{.*}}) -> ()
@@ -114,7 +114,7 @@ void ppp() { B b; }
// Constructor for B
// CIR: cir.func {{.*}} @_ZN1BC1Ev(%arg0: !cir.ptr<!rec_B>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
// CIR: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
// CIR: %[[BASE_A_ADDR:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_B> nonnull [12] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/CodeGen/vector-ext-element.cpp b/clang/test/CIR/CodeGen/vector-ext-element.cpp
index 502e5f2df6324..340d31fdd6f0a 100644
--- a/clang/test/CIR/CodeGen/vector-ext-element.cpp
+++ b/clang/test/CIR/CodeGen/vector-ext-element.cpp
@@ -14,9 +14,9 @@ void element_expr_from_gl() {
int y = a.y;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[Y_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[ELEM_0:.*]] = cir.vec.extract %[[TMP_A]][%[[CONST_0]] : !s64i] : !cir.vector<4 x !s32i>
@@ -52,9 +52,9 @@ void element_expr_from_gl_with_vec_result() {
vi4 c = a.wzyx;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s32i>
// CIR: %[[B_VALUE:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[POISON]] : !cir.vector<4 x !s32i>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i] : !cir.vector<2 x !s32i>
@@ -90,9 +90,9 @@ void element_expr_from_pointer() {
int Y = a->y;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!cir.vector<4 x !s32i>>, !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>, ["a"]
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["X", init]
-// CIR: %[[Y_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["Y", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.ptr<!cir.vector<4 x !s32i>> -> !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "X" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[Y_ADDR:.*]] = cir.alloca "Y" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP_A_PTR:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[TMP_A_PTR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
@@ -134,9 +134,9 @@ void element_expr_from_pointer_with_vec_result() {
vi4 c = a->wzyx;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!cir.vector<4 x !s32i>>, !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.ptr<!cir.vector<4 x !s32i>> -> !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A_PTR:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[TMP_A_PTR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s32i>
@@ -179,12 +179,12 @@ void element_expr_from_rvalue() {
int y = (a + b).y;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["tmp"]
-// CIR: %[[Y_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init]
-// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["tmp"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[ADD_A_B:.*]] = cir.add %[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>
@@ -251,12 +251,12 @@ void element_expr_from_rvalue_with_vec_result() {
vi4 d = (a + b).wzyx;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["c", init]
-// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["tmp"]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["d", init]
-// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["tmp"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[ADD_A_B:.*]] = cir.add %[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>
@@ -321,7 +321,7 @@ void array_subscript_expr_with_element_expr_base() {
a.xyz[1] = 2;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[A_PTR:.*]] = cir.cast bitcast %0 : !cir.ptr<!cir.vector<4 x !s32i>> -> !cir.ptr<!s32i>
@@ -346,8 +346,8 @@ void store_src_dest_same_size() {
b.xy = a.xy;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s32i>
// CIR: %[[SHUFFLE_A:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[POISON]] : !cir.vector<4 x !s32i>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i] : !cir.vector<2 x !s32i>
@@ -378,8 +378,8 @@ void store_src_dest_not_same_size() {
a.lo = b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["b"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<2 x !s32i>>, !cir.vector<2 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<2 x !s32i>
@@ -408,8 +408,8 @@ void non_simple_base() {
int b = a.xy.x;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[RESULT:.*]] = cir.vec.extract %[[TMP_A]][%[[CONST_0]] : !s64i] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/CodeGen/vector-ext.cpp b/clang/test/CIR/CodeGen/vector-ext.cpp
index 3f8dc59988667..607b047604619 100644
--- a/clang/test/CIR/CodeGen/vector-ext.cpp
+++ b/clang/test/CIR/CodeGen/vector-ext.cpp
@@ -70,14 +70,14 @@ void foo() {
vi4 h = {};
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<3 x !s32i>, !cir.ptr<!cir.vector<3 x !s32i>>, ["b"]
-// CIR: %[[VEC_C:.*]] = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["c"]
-// CIR: %[[VEC_D:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["d"]
-// CIR: %[[VEC_E:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["e", init]
-// CIR: %[[VEC_F:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["f", init]
-// CIR: %[[VEC_G:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["g", init]
-// CIR: %[[VEC_H:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["h", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<3 x !s32i> -> !cir.ptr<!cir.vector<3 x !s32i>>
+// CIR: %[[VEC_C:.*]] = cir.alloca "c" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[VEC_D:.*]] = cir.alloca "d" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[VEC_E:.*]] = cir.alloca "e" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_F:.*]] = cir.alloca "f" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_G:.*]] = cir.alloca "g" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_H:.*]] = cir.alloca "h" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_E_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_E_VAL]], %[[VEC_E]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -127,7 +127,7 @@ void foo() {
void foo2(vi4 p) {}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["p", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "p" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store{{.*}} %{{.*}}, %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// LLVM: %[[VEC_A:.*]] = alloca <4 x i32>, i64 1, align 16
@@ -141,8 +141,8 @@ void foo3() {
int e = a[1];
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -172,9 +172,9 @@ void foo4() {
int e = a[idx];
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[IDX:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["idx", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -211,7 +211,7 @@ void foo5() {
a[2] = 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -240,9 +240,9 @@ void foo6() {
a[idx] = value;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[IDX:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["idx", init]
-// CIR: %[[VAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["value", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VAL:.*]] = cir.alloca "value" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -285,7 +285,7 @@ void foo7() {
a[2] += 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -324,10 +324,10 @@ void foo8() {
vi4 not_res = ~a;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[PLUS_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["plus_res", init]
-// CIR: %[[MINUS_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["minus_res", init]
-// CIR: %[[NOT_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["not_res", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[PLUS_RES:.*]] = cir.alloca "plus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[MINUS_RES:.*]] = cir.alloca "minus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[NOT_RES:.*]] = cir.alloca "not_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -376,10 +376,10 @@ void foo9() {
vi4 shr = a >> b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
-// CIR: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
-// CIR: %[[SHR_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shr", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -433,10 +433,10 @@ void foo10() {
uvi4 shr = b >> a;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["b", init]
-// CIR: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
-// CIR: %[[SHR_RES:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["shr", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -496,8 +496,8 @@ void foo11() {
vi4 j = a ^ b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -623,8 +623,8 @@ void foo12() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -738,8 +738,8 @@ void foo13() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !u32i, #cir.int<2> : !u32i,
// CIR-SAME: #cir.int<3> : !u32i, #cir.int<4> : !u32i]> : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>
@@ -853,8 +853,8 @@ void foo14() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float,
// CIR-SAME: #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
@@ -1045,7 +1045,7 @@ void foo17() {
vus2 W = __builtin_convertvector(a, vus2);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["a"]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
// CIR: %[[RES:.*]] = cir.cast float_to_int %[[TMP]] : !cir.vector<2 x !cir.double> -> !cir.vector<2 x !u16i>
@@ -1065,10 +1065,10 @@ void foo18() {
uvi4 shr = b >> 3u;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["b", init]
-// CIR: %[[SHR_RES:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["shr", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CIR-SAME: #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1118,8 +1118,8 @@ void foo19() {
vi4 u = __builtin_shufflevector(a, b, 7, 5, 3, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<7> :
@@ -1143,8 +1143,8 @@ void foo20() {
vi4 u = __builtin_shufflevector(a, b, -1, 1, -1, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<-1> :
@@ -1167,7 +1167,7 @@ void foo21() {
unsigned long size = __builtin_vectorelements(a);
}
-// CIR: %[[INIT:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["size", init]
+// CIR: %[[INIT:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: cir.store align(8) %[[SIZE]], %[[INIT]] : !u64i, !cir.ptr<!u64i>
@@ -1183,9 +1183,9 @@ void logical_or_vi4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1223,9 +1223,9 @@ void logical_or_vf4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1263,9 +1263,9 @@ void foo24() {
vh4 c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.f16>, !cir.ptr<!cir.vector<4 x !cir.f16>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.f16>, !cir.ptr<!cir.vector<4 x !cir.f16>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.f16>, !cir.ptr<!cir.vector<4 x !cir.f16>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
// CIR: %[[TMP_A_F16:.*]] = cir.cast floating %[[TMP_A]] : !cir.vector<4 x !cir.f16> -> !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
@@ -1302,9 +1302,9 @@ void logical_and_vi4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1342,9 +1342,9 @@ void logical_and_vf4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1381,8 +1381,8 @@ void logical_not() {
vi4 b = !a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}}) %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
@@ -1407,8 +1407,8 @@ void unary_extension() {
vi4 b = __extension__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1429,10 +1429,10 @@ vi4 ternary_expression_with_vec_cond() {
return c ? a : b;
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["__retval"]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_C:.*]] = cir.load {{.*}} %[[C_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/CodeGen/vector.cpp b/clang/test/CIR/CodeGen/vector.cpp
index fe63c776818d6..d25ecea2d89f6 100644
--- a/clang/test/CIR/CodeGen/vector.cpp
+++ b/clang/test/CIR/CodeGen/vector.cpp
@@ -60,13 +60,13 @@ void foo() {
vi4 g = {};
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["b"]
-// CIR: %[[VEC_C:.*]] = cir.alloca !cir.vector<2 x !s64i>, !cir.ptr<!cir.vector<2 x !s64i>>, ["c"]
-// CIR: %[[VEC_D:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["d", init]
-// CIR: %[[VEC_E:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["e", init]
-// CIR: %[[VEC_F:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["f", init]
-// CIR: %[[VEC_G:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["g", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[VEC_C:.*]] = cir.alloca "c" {{.*}} !cir.vector<2 x !s64i> -> !cir.ptr<!cir.vector<2 x !s64i>>
+// CIR: %[[VEC_D:.*]] = cir.alloca "d" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_E:.*]] = cir.alloca "e" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_F:.*]] = cir.alloca "f" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_G:.*]] = cir.alloca "g" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_D_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_D_VAL]], %[[VEC_D]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -114,7 +114,7 @@ void foo() {
void foo2(vi4 p) {}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["p", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "p" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store{{.*}} %{{.*}}, %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// LLVM: %[[VEC_A:.*]] = alloca <4 x i32>, i64 1, align 16
@@ -128,8 +128,8 @@ void foo3() {
int e = a[1];
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -159,9 +159,9 @@ void foo4() {
int e = a[idx];
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[IDX:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["idx", init]
-// CIR: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -198,7 +198,7 @@ void foo5() {
a[2] = 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -227,9 +227,9 @@ void foo6() {
a[idx] = value;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[IDX:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["idx", init]
-// CIR: %[[VAL:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["value", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VAL:.*]] = cir.alloca "value" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -272,7 +272,7 @@ void foo7() {
a[2] += 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -311,10 +311,10 @@ void foo8() {
vi4 not_res = ~a;
}
-// CIR: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[PLUS_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["plus_res", init]
-// CIR: %[[MINUS_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["minus_res", init]
-// CIR: %[[NOT_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["not_res", init]
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[PLUS_RES:.*]] = cir.alloca "plus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[MINUS_RES:.*]] = cir.alloca "minus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[NOT_RES:.*]] = cir.alloca "not_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -363,10 +363,10 @@ void foo9() {
vi4 shr = a >> b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
-// CIR: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
-// CIR: %[[SHR_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shr", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -420,10 +420,10 @@ void foo10() {
uvi4 shr = b >> a;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["b", init]
-// CIR: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
-// CIR: %[[SHR_RES:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["shr", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -483,8 +483,8 @@ void foo11() {
vi4 j = a ^ b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -610,8 +610,8 @@ void foo12() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -725,8 +725,8 @@ void foo13() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !u32i, #cir.int<2> : !u32i,
// CIR-SAME: #cir.int<3> : !u32i, #cir.int<4> : !u32i]> : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>
@@ -840,8 +840,8 @@ void foo14() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float,
// CIR-SAME: #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
@@ -1032,7 +1032,7 @@ void foo17() {
vus2 W = __builtin_convertvector(a, vus2);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["a"]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
// CIR: %[[RES:.*]] = cir.cast float_to_int %[[TMP]] : !cir.vector<2 x !cir.double> -> !cir.vector<2 x !u16i>
@@ -1052,10 +1052,10 @@ void foo18() {
uvi4 shr = b >> 3u;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["b", init]
-// CIR: %[[SHR_RES:.*]] = cir.alloca !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>, ["shr", init]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CIR-SAME: #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1105,8 +1105,8 @@ void foo19() {
vi4 u = __builtin_shufflevector(a, b, 7, 5, 3, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<7> :
@@ -1185,8 +1185,8 @@ void foo23() {
vi4 u = __builtin_shufflevector(a, b, -1, 1, -1, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<-1> :
@@ -1209,7 +1209,7 @@ void foo24() {
unsigned long size = __builtin_vectorelements(a);
}
-// CIR: %[[INIT:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["size", init]
+// CIR: %[[INIT:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: cir.store align(8) %[[SIZE]], %[[INIT]] : !u64i, !cir.ptr<!u64i>
@@ -1225,9 +1225,9 @@ void logical_or_vi4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1265,9 +1265,9 @@ void logical_or_vf4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1305,9 +1305,9 @@ void foo27() {
vh4 c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.f16>, !cir.ptr<!cir.vector<4 x !cir.f16>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.f16>, !cir.ptr<!cir.vector<4 x !cir.f16>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.f16>, !cir.ptr<!cir.vector<4 x !cir.f16>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
// CIR: %[[TMP_A_F16:.*]] = cir.cast floating %[[TMP_A]] : !cir.vector<4 x !cir.f16> -> !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
@@ -1344,9 +1344,9 @@ void logical_and_vi4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1384,9 +1384,9 @@ void logical_and_vf4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1423,8 +1423,8 @@ void logical_not() {
vi4 b = !a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}}) %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
@@ -1449,8 +1449,8 @@ void logical_not_float() {
vi4 b = !a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
@@ -1475,8 +1475,8 @@ void unary_extension() {
vi4 b = __extension__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1497,10 +1497,10 @@ vi4 ternary_expression_with_vec_cond() {
return c ? a : b;
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["__retval"]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c"]
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_C:.*]] = cir.load {{.*}} %[[C_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp b/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp
index 7f31106661aef..51e0a1dc564b0 100644
--- a/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp
+++ b/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp
@@ -135,7 +135,7 @@ class D {
D::~D() = default;
// CIR: cir.func{{.*}} @_ZN1DD2Ev
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>, ["this", init] {alignment = 8 : i64}
+// CIR: %[[THIS:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
// CIR: cir.store %[[ARG0:.*]], %[[THIS]] : !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[THIS1:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_D>>, !cir.ptr<!rec_D>
// CIR: cir.return
@@ -155,7 +155,7 @@ D::~D() = default;
// CIR: cir.func {{.*}} @_ZN1DD1Ev(!cir.ptr<!rec_D>) alias(@_ZN1DD2Ev)
// CIR: cir.func{{.*}} @_ZN1DD0Ev
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>, ["this", init] {alignment = 8 : i64}
+// CIR: %[[THIS:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
// CIR: cir.store %[[ARG0:.*]], %[[THIS]] : !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[THIS1:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_D>>, !cir.ptr<!rec_D>
// CIR: cir.trap
diff --git a/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp b/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp
index 71f749d53dc58..a69145213ee98 100644
--- a/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp
+++ b/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp
@@ -18,7 +18,7 @@ void call_virtual_fn_in_cleanup_scope() {
}
// CIR: cir.func {{.*}} @_Z32call_virtual_fn_in_cleanup_scopev()
-// CIR: %[[B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["b", init]
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
// CIR: cir.call @_ZN1BC2Ev(%[[B]])
// CIR: cir.cleanup.scope {
// CIR: %[[C_LITERAL:.*]] = cir.const #cir.int<99> : !s8i
@@ -30,7 +30,7 @@ void call_virtual_fn_in_cleanup_scope() {
// CIR: }
// CIR-FLAT: cir.func {{.*}} @_Z32call_virtual_fn_in_cleanup_scopev()
-// CIR-FLAT: %[[B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["b", init]
+// CIR-FLAT: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
// CIR-FLAT: cir.call @_ZN1BC2Ev(%[[B]]) nothrow : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CIR-FLAT: cir.br ^[[CLEANUP_SCOPE:bb[0-9]+]]
// CIR-FLAT: ^[[CLEANUP_SCOPE]]:
diff --git a/clang/test/CIR/CodeGen/virtual-function-calls.cpp b/clang/test/CIR/CodeGen/virtual-function-calls.cpp
index e267cabf179a7..4e1696703ad03 100644
--- a/clang/test/CIR/CodeGen/virtual-function-calls.cpp
+++ b/clang/test/CIR/CodeGen/virtual-function-calls.cpp
@@ -23,7 +23,7 @@ A::A() {}
// OGCG: @_ZTV1A = external constant { [3 x ptr] }
// CIR: cir.func{{.*}} @_ZN1AC2Ev(%arg0: !cir.ptr<!rec_A> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["this", init]
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
// CIR: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[VPTR:.*]] = cir.vtable.address_point(@_ZTV1A, address_point = <index = 0, offset = 2>) : !cir.vptr
@@ -52,7 +52,7 @@ void f1(A *a) {
}
// CIR: cir.func{{.*}} @_Z2f1P1A(%arg0: !cir.ptr<!rec_A> {{.*}})
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!rec_A>
+// CIR: %[[A_ADDR:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_A>
// CIR: cir.store %arg0, %[[A_ADDR]]
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_ADDR]]
// CIR: %[[C_LITERAL:.*]] = cir.const #cir.int<99> : !s8i
@@ -91,7 +91,7 @@ void call_virtual_fn_in_cleanup_scope() {
}
// CIR: cir.func {{.*}} @_Z32call_virtual_fn_in_cleanup_scopev()
-// CIR: %[[B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["b", init]
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
// CIR: cir.call @_ZN1BC2Ev(%[[B]])
// CIR: cir.cleanup.scope {
// CIR: %[[C_LITERAL:.*]] = cir.const #cir.int<99> : !s8i
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index c205808ec78fa..e61e114a195f4 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -10,14 +10,14 @@ void f0(int len) {
}
// CIR: cir.func{{.*}} @f0(%[[LEN_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[LEN_SIZE_T]] : !u64i, ["arr"]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[LEN_SIZE_T]] : !u64i, !s32i -> !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
@@ -95,8 +95,8 @@ void f1(int len) {
}
// CIR: cir.func{{.*}} @f1(%[[LEN_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[SIXTEEN:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
@@ -104,7 +104,7 @@ void f1(int len) {
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
// CIR: %[[TOTAL_LEN:.*]] = cir.mul nuw %[[SIXTEEN]], %[[LEN_SIZE_T]]
-// CIR: %[[ARR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[TOTAL_LEN]] : !u64i, ["arr"]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[TOTAL_LEN]] : !u64i, !s32i -> !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
@@ -143,8 +143,8 @@ void f2(int len) {
}
// CIR: cir.func{{.*}} @f2(%[[LEN_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["len", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
@@ -152,7 +152,7 @@ void f2(int len) {
// CIR: %[[TOTAL_LEN_SIZE_T:.*]] = cir.cast integral %[[TOTAL_LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[TOTAL_LEN_SIZE_T]] : !u64i, ["arr"]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[TOTAL_LEN_SIZE_T]] : !u64i, !s32i -> !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
@@ -195,15 +195,15 @@ void f3(unsigned len) {
}
// CIR: cir.func{{.*}} @f3(%[[LEN_ARG:.*]]: !u32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["len", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
-// CIR: %[[I:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["i", init]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !u32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[S1:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, %[[LEN_SIZE_T]] : !u64i, ["s1"]
+// CIR: %[[S1:.*]] = cir.alloca "s1" {{.*}} %[[LEN_SIZE_T]] : !u64i, !s8i -> !cir.ptr<!s8i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[I]]
// CIR: cir.scope {
@@ -216,12 +216,12 @@ void f3(unsigned len) {
// CIR: cir.condition(%[[CMP]])
// CIR: } do {
// CIR: cir.scope {
-// CIR: %[[SAVED_STACK2:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[SAVED_STACK2:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[I_LEN:.*]] = cir.load{{.*}} %[[I]]
// CIR: %[[I_LEN_SIZE_T2:.*]] = cir.cast integral %[[I_LEN]] : !u32i -> !u64i
// CIR: %[[STACK_PTR2:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR2]], %[[SAVED_STACK2]]
-// CIR: %[[S2:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, %[[I_LEN_SIZE_T2]] : !u64i, ["s2"]
+// CIR: %[[S2:.*]] = cir.alloca "s2" {{.*}} %[[I_LEN_SIZE_T2]] : !u64i, !s8i -> !cir.ptr<!s8i>
// CIR: %[[SAVED_RESTORE_PTR2:.*]] = cir.load{{.*}} %[[SAVED_STACK2]]
// CIR: cir.stackrestore %[[SAVED_RESTORE_PTR2]]
// CIR: }
@@ -329,14 +329,14 @@ int f5(unsigned long len) {
}
// CIR: cir.func{{.*}} @f5(%[[LEN_ARG:.*]]: !u64i {{.*}}) -> !s32i
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["len", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[LEN]] : !u64i, ["arr"]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[LEN]] : !u64i, !s32i -> !cir.ptr<!s32i>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s64i
// CIR: %[[ARR_2:.*]] = cir.ptr_stride %[[ARR]], %[[TWO]]
// CIR: %[[ARR_VAL:.*]] = cir.load{{.*}} %[[ARR_2]] : !cir.ptr<!s32i>, !s32i
@@ -387,9 +387,9 @@ void vla_subscript_expr() {
(int (**)[n]){&a}[0][1][5] = 0;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["a"]
-// CIR: %[[N_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init]
-// CIR: %[[COMPOUND_ADDR:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, [".compoundliteral"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[COMPOUND_ADDR:.*]] = cir.alloca ".compoundliteral" {{.*}} !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CIR: %[[CONST_5:.*]] = cir.const #cir.int<5> : !u64i
// CIR: cir.store {{.*}} %[[CONST_5]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_0_VAL:.*]] = cir.const #cir.int<0> : !s32i
@@ -440,10 +440,10 @@ double vla_param_2d(int n, double m[n][n], int i, int j) {
}
// CIR: cir.func{{.*}} @vla_param_2d(%[[N_ARG:.*]]: !s32i {{.*}}, %[[M_ARG:.*]]: !cir.ptr<!cir.double> {{.*}}, %[[I_ARG:.*]]: !s32i {{.*}}, %[[J_ARG:.*]]: !s32i {{.*}}) -> !cir.double
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR: %[[M_ADDR:.*]] = cir.alloca !cir.ptr<!cir.double>, !cir.ptr<!cir.ptr<!cir.double>>, ["m", init]
-// CIR: %[[I_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
-// CIR: %[[J_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["j", init]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[J_ADDR:.*]] = cir.alloca "j" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[N_ARG]], %[[N_ADDR]]
// CIR: cir.store{{.*}} %[[M_ARG]], %[[M_ADDR]]
// CIR: cir.store{{.*}} %[[I_ARG]], %[[I_ADDR]]
@@ -512,15 +512,15 @@ void complex_vla_cast(int n) {
}
// CIR: cir.func {{.*}} @complex_vla_cast
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store %{{.*}}, %[[LEN_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[LEN:.*]] = cir.load {{.*}} %[[LEN_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_PTR]], %[[SAVED_STACK]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ArR:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, %3 : !u64i, ["arr"]
+// CIR: %[[ArR:.*]] = cir.alloca "arr" {{.*}} %3 : !u64i, !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.yield
// CIR: } cleanup normal {
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load {{.*}} %[[SAVED_STACK]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGen/vtt.cpp b/clang/test/CIR/CodeGen/vtt.cpp
index e646101f4feda..ed7284ea8869d 100644
--- a/clang/test/CIR/CodeGen/vtt.cpp
+++ b/clang/test/CIR/CodeGen/vtt.cpp
@@ -274,8 +274,8 @@ D::D() {}
// CIR-COMMON: cir.func {{.*}} @_ZN1BC2Ev
// CIR-COMMON-SAME: %[[THIS_ARG:.*]]: !cir.ptr<!rec_B>
// CIR-COMMON-SAME: %[[VTT_ARG:.*]]: !cir.ptr<!cir.ptr<!void>>
-// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR-COMMON: %[[VTT_ADDR:.*]] = cir.alloca {{.*}} ["vtt", init]
+// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR-COMMON: %[[VTT_ADDR:.*]] = cir.alloca "vtt" {{.*}} init
// CIR-COMMON: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR-COMMON: cir.store %[[VTT_ARG]], %[[VTT_ADDR]]
// CIR-COMMON: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -340,8 +340,8 @@ D::D() {}
// CIR-COMMON: cir.func {{.*}} @_ZN1CC2Ev
// CIR-COMMON-SAME: %[[THIS_ARG:.*]]: !cir.ptr<!rec_C>
// CIR-COMMON-SAME: %[[VTT_ARG:.*]]: !cir.ptr<!cir.ptr<!void>>
-// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR-COMMON: %[[VTT_ADDR:.*]] = cir.alloca {{.*}} ["vtt", init]
+// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR-COMMON: %[[VTT_ADDR:.*]] = cir.alloca "vtt" {{.*}} init
// CIR-COMMON: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR-COMMON: cir.store %[[VTT_ARG]], %[[VTT_ADDR]]
// CIR-COMMON: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -406,8 +406,8 @@ D::D() {}
// CIR-COMMON: cir.func {{.*}} @_ZN1DC2Ev
// CIR-COMMON-SAME: %[[THIS_ARG:.*]]: !cir.ptr<!rec_D>
// CIR-COMMON-SAME: %[[VTT_ARG:.*]]: !cir.ptr<!cir.ptr<!void>>
-// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
-// CIR-COMMON: %[[VTT_ADDR:.*]] = cir.alloca {{.*}} ["vtt", init]
+// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
+// CIR-COMMON: %[[VTT_ADDR:.*]] = cir.alloca "vtt" {{.*}} init
// CIR-COMMON: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR-COMMON: cir.store %[[VTT_ARG]], %[[VTT_ADDR]]
// CIR-COMMON: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
@@ -477,7 +477,7 @@ D::D() {}
// CIR-COMMON: cir.func {{.*}} @_ZN1AC2Ev
// CIR-COMMON-SAME: %[[THIS_ARG:.*]]: !cir.ptr<!rec_A>
-// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CIR-COMMON: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR-COMMON: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR-COMMON: %[[VPTR:.*]] = cir.vtable.address_point(@_ZTV1A, address_point = <index = 0, offset = 2>) : !cir.vptr
@@ -496,7 +496,7 @@ D::D() {}
// CIR-COMMON: cir.func {{.*}} @_ZN1DC1Ev
// CIR-COMMON-SAME: %[[THIS_ARG:.*]]: !cir.ptr<!rec_D>
-// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca {{.*}} ["this", init]
+// CIR-COMMON: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
// CIR-COMMON: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR-COMMON: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR-COMMON: %[[A_ADDR:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_D> nonnull [40] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp
index 3b7f710977066..4f182f6b3c41c 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp
@@ -15,8 +15,8 @@ void builtin_address_of() {
Container* b = __builtin_addressof(a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !rec_Container, !cir.ptr<!rec_Container>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Container>, !cir.ptr<!cir.ptr<!rec_Container>>, ["b", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_Container -> !cir.ptr<!rec_Container>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!rec_Container> -> !cir.ptr<!cir.ptr<!rec_Container>>
// CIR: cir.store {{.*}} %[[A_ADDR]], %[[B_ADDR]] : !cir.ptr<!rec_Container>, !cir.ptr<!cir.ptr<!rec_Container>>
// LLVM: %[[A_ADDR:.*]] = alloca %struct.Container, i64 1, align 4
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp
index 47e693c5645d0..21a6047e2ca71 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp
@@ -7,8 +7,8 @@
void foo(void) {
// CIR-LABEL: cir.func no_inline 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: %[[V0:.*]] = cir.alloca "f4" align(16) !cir.array<!cir.float x 4> -> !cir.ptr<!cir.array<!cir.float x 4>>
+ // CIR: %[[V1:.*]] = cir.alloca "f8" align(16) !cir.array<!cir.float x 8> -> !cir.ptr<!cir.array<!cir.float x 8>>
// 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>
@@ -116,8 +116,8 @@ void testbcopy(const void *src, void *dest, size_t n) {
}
// CIR-LABEL: @testaddressof(
-// CIR: %[[SRC:.*]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["src", init]
-// CIR: %[[DEST:.*]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["dest", init]
+// CIR: %[[SRC:.*]] = cir.alloca "src" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[DEST:.*]] = cir.alloca "dest" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[SRC_TO_VOIDPTR:.*]] = cir.cast bitcast %[[SRC]] : !cir.ptr<!cir.ptr<!s8i>> -> !cir.ptr<!void>
// CIR: %[[DEST_TO_VOIDPTR:.*]] = cir.cast bitcast %[[DEST]] : !cir.ptr<!cir.ptr<!s8i>> -> !cir.ptr<!void>
// CIR: cir.libc.memmove {{.*}} bytes from %[[SRC_TO_VOIDPTR]] to %[[DEST_TO_VOIDPTR]]
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp
index c71f6a166d982..efda15add74ac 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp
@@ -118,7 +118,7 @@ two_ints test_rvalue_aggregate() {
}
// CIR-LABEL: cir.func {{.*}} @_Z21test_rvalue_aggregatev()
-// CIR: %[[#TMP_SLOT:]] = cir.alloca !u64i, !cir.ptr<!u64i>
+// CIR: %[[#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>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp
index b60cb974b1518..eca2327ec44c8 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp
@@ -324,7 +324,7 @@ void *test_alloca(unsigned long n) {
}
// CIR-LABEL: @_Z11test_allocam(
-// CIR: %{{.+}} = cir.alloca !u8i, !cir.ptr<!u8i>, %{{.+}} : !u64i, ["bi_alloca"]
+// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} %{{.+}} : !u64i, !u8i -> !cir.ptr<!u8i>
// LLVM-LABEL: @_Z11test_allocam(
// LLVM: alloca i8, i64 %{{.+}}
@@ -339,8 +339,8 @@ bool test_multiple_allocas(unsigned long n) {
}
// CIR-LABEL: @_Z21test_multiple_allocasm(
-// CIR: %{{.+}} = cir.alloca !u8i, !cir.ptr<!u8i>, %{{.+}} : !u64i, ["bi_alloca"]
-// CIR: %{{.+}} = cir.alloca !u8i, !cir.ptr<!u8i>, %{{.+}} : !u64i, ["bi_alloca"]
+// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} %{{.+}} : !u64i, !u8i -> !cir.ptr<!u8i>
+// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} %{{.+}} : !u64i, !u8i -> !cir.ptr<!u8i>
// LLVM-LABEL: @_Z21test_multiple_allocasm(
// LLVM: alloca i8, i64 %{{.+}}
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c b/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c
index 84bce02c82361..6f57a4b0b1f09 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c
@@ -24,7 +24,7 @@ struct foo test0(int expr) {
}
// CIR: cir.func {{.*}} @test0(%[[ARG0:.*]]: !s32i {{.*}}) -> !rec_foo
-// CIR: %[[EXPR_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["expr", init]
+// CIR: %[[EXPR_ADDR:.*]] = cir.alloca "expr" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], %[[EXPR_ADDR]]
// CIR: %[[EXPR:.*]] = cir.load{{.*}} %[[EXPR_ADDR]]
// CIR: %[[IS_CONSTANT:.*]] = cir.is_constant %[[EXPR]] : !s32i -> !cir.bool
@@ -48,7 +48,7 @@ int test1(void) {
}
// CIR: cir.func {{.*}} @test1() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -72,7 +72,7 @@ int test2(void) {
}
// CIR: cir.func {{.*}} @test2() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -94,7 +94,7 @@ int test3(void) {
}
// CIR: cir.func {{.*}} @test3() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -118,7 +118,7 @@ int test4(void) {
}
// CIR: cir.func {{.*}} @test4() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -142,7 +142,7 @@ int test5(void) {
}
// CIR: cir.func {{.*}} @test5() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store %[[ONE]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -187,7 +187,7 @@ int test7(void) {
}
// CIR: cir.func {{.*}} @test7() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store %[[ONE]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -207,7 +207,7 @@ int test8(void) {
}
// CIR: cir.func {{.*}} @test8() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -229,7 +229,7 @@ int test9(void) {
}
// CIR: cir.func {{.*}} @test9() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -249,7 +249,7 @@ int test10(void) {
}
// CIR: cir.func {{.*}} @test10() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store %[[ONE]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c b/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
index 03378cae96f1a..1f328fd17a600 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
@@ -11,9 +11,9 @@ typedef double __m128d __attribute__((__vector_size__(16), __aligned__(16)));
__m128 test_cmpnleps(__m128 A, __m128 B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnleps(
// CIR: %[[ARG0:.*]]: !cir.vector<4 x !cir.float> {{.*}}, %[[ARG1:.*]]: !cir.vector<4 x !cir.float> {{.*}}) -> !cir.vector<4 x !cir.float> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["A", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["B", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["__retval"] {alignment = 16 : i64}
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -62,9 +62,9 @@ __m128 test_cmpnleps(__m128 A, __m128 B) {
__m128d test_cmpnlepd(__m128d A, __m128d B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnlepd(
// CIR: %[[ARG0:.*]]: !cir.vector<2 x !cir.double> {{.*}}, %[[ARG1:.*]]: !cir.vector<2 x !cir.double> {{.*}}) -> !cir.vector<2 x !cir.double> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["A", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["B", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["__retval"] {alignment = 16 : i64}
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
@@ -113,9 +113,9 @@ __m128d test_cmpnlepd(__m128d A, __m128d B) {
__m128 test_cmpnltps(__m128 A, __m128 B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnltps(
// CIR: %[[ARG0:.*]]: !cir.vector<4 x !cir.float> {{.*}}, %[[ARG1:.*]]: !cir.vector<4 x !cir.float> {{.*}}) -> !cir.vector<4 x !cir.float> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["A", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["B", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["__retval"] {alignment = 16 : i64}
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -164,9 +164,9 @@ __m128 test_cmpnltps(__m128 A, __m128 B) {
__m128d test_cmpnltpd(__m128d A, __m128d B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnltpd(
// CIR: %[[ARG0:.*]]: !cir.vector<2 x !cir.double> {{.*}}, %[[ARG1:.*]]: !cir.vector<2 x !cir.double> {{.*}}) -> !cir.vector<2 x !cir.double> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["A", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["B", init] {alignment = 16 : i64}
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["__retval"] {alignment = 16 : i64}
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp
index f62da9e6d9413..127409d8e3993 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp
@@ -19,10 +19,10 @@ void offset_of_builtin() {
unsigned long d = __builtin_offsetof(Struct, d);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["c", init]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["d", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !u64i
// CIR: cir.store {{.*}} %[[CONST_0]], %[[A_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_4:.*]] = cir.const #cir.int<4> : !u64i
@@ -61,10 +61,10 @@ void offset_of_builtin_from_array_element() {
unsigned long d = __builtin_offsetof(StructWithArray, array[3][3].d);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["b", init]
-// CIR: %[[C_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["c", init]
-// CIR: %[[D_ADDR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["d", init]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !u64i -> !cir.ptr<!u64i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !u64i
// CIR: cir.store {{.*}} %[[CONST_0]], %[[A_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_124:.*]] = cir.const #cir.int<124> : !u64i
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c b/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c
index 15eb37bb2f88b..de485bf4b1e4e 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c
@@ -10,7 +10,7 @@ void foo(void *a) {
}
// CIR-LABEL: cir.func {{.*}} @foo(
-// CIR: %[[ALLOCA:.*]] = cir.alloca !cir.ptr<!void>
+// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} !cir.ptr<!void>
// CIR: cir.store %arg0, %[[ALLOCA]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[P1:.*]] = cir.load{{.*}} %[[ALLOCA]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: cir.prefetch read locality(3) %[[P1]] : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp
index 2a0f5c4196a8d..21e3ae8b6fc4d 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp
@@ -21,8 +21,8 @@ void func(char const * const str, int i) {
// CIR: cir.func{{.*}} @printf(!cir.ptr<!s8i> {{.*}}, ...) -> !s32i
// CIR: cir.func{{.*}} @_Z4funcPKci(%[[arg0:.+]]: !cir.ptr<!s8i>{{.*}}, %[[arg1:.+]]: !s32i
-// CIR: %[[str_ptr:.+]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>, ["str", init, const]
-// CIR: %[[i_ptr:.+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
+// CIR: %[[str_ptr:.+]] = cir.alloca "str" {{.*}} init const !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[i_ptr:.+]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %[[arg0]], %[[str_ptr]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
// CIR: cir.store %[[arg1]], %[[i_ptr]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[null_ptr:.+]] = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c b/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c
index 072d9c6531e47..1e536f1c17b3d 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c
@@ -7,7 +7,7 @@
void test_setjmp(void *env) {
// CIR-LABEL: test_setjmp
// CIR-SAME: [[ENV:%.*]]:
- // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>,
+ // 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>>
@@ -44,7 +44,7 @@ void test_setjmp(void *env) {
void test_longjmp(void *env) {
// CIR-LABEL: test_longjmp
// CIR-SAME: [[ENV:%.*]]:
- // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>,
+ // 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>>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c b/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c
index e3ce1440ca595..4c6a771e4b806 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c
@@ -8,7 +8,7 @@
void test_signbit_positive_zero(){
double positiveZero = +0.0;
int result = __builtin_signbit(positiveZero);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["positiveZero", init]
+// CIR: cir.alloca "positiveZero" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -22,7 +22,7 @@ void test_signbit_positive_zero(){
void test_signbit_negative_zero(){
double negativeZero = -0.0;
int result = __builtin_signbit(negativeZero);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["negativeZero", init]
+// CIR: cir.alloca "negativeZero" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<-0.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -36,7 +36,7 @@ void test_signbit_negative_zero(){
void test_signbit_positive_number(){
double positiveNumber = 1.0;
int result = __builtin_signbit(positiveNumber);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["positiveNumber", init]
+// CIR: cir.alloca "positiveNumber" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<1.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -50,7 +50,7 @@ void test_signbit_positive_number(){
void test_signbit_negative_number(){
double negativeNumber = -1.0;
int result = __builtin_signbit(negativeNumber);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["negativeNumber", init]
+// CIR: cir.alloca "negativeNumber" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<-1.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -64,7 +64,7 @@ void test_signbit_negative_number(){
void test_signbit_positive_nan(){
double positiveNan = +__builtin_nan("");
int result = __builtin_signbit(positiveNan);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["positiveNan", init]
+// CIR: cir.alloca "positiveNan" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0x7FF8000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -78,7 +78,7 @@ void test_signbit_positive_nan(){
void test_signbit_negative_nan(){
double negativeNan = -__builtin_nan("");
int result = __builtin_signbit(negativeNan);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["negativeNan", init]
+// CIR: cir.alloca "negativeNan" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0xFFF8000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -92,7 +92,7 @@ void test_signbit_negative_nan(){
void test_signbit_positive_infinity(){
double positiveInfinity = +__builtin_inf();
int result = __builtin_signbit(positiveInfinity);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["positiveInfinity", init]
+// CIR: cir.alloca "positiveInfinity" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0x7FF0000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -106,7 +106,7 @@ void test_signbit_positive_infinity(){
void test_signbit_negative_infinity(){
double negativeInfinity = -__builtin_inf();
int result = __builtin_signbit(negativeInfinity);
-// CIR: cir.alloca !cir.double, !cir.ptr<!cir.double>, ["negativeInfinity", init]
+// CIR: cir.alloca "negativeInfinity" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0xFFF0000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
diff --git a/clang/test/CIR/CodeGenCUDA/address-spaces.cu b/clang/test/CIR/CodeGenCUDA/address-spaces.cu
index 54ab665838596..acd83bd036501 100644
--- a/clang/test/CIR/CodeGenCUDA/address-spaces.cu
+++ b/clang/test/CIR/CodeGenCUDA/address-spaces.cu
@@ -158,7 +158,7 @@ __global__ void fn() {
}
// CIR-DEVICE: cir.func {{.*}}@_Z2fnv() {{.*}} {
-// CIR-DEVICE: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init]
+// CIR-DEVICE: %[[ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR-DEVICE: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-DEVICE: cir.store {{.*}}%[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CIR-DEVICE: %[[J:.*]] = cir.get_global @_ZZ2fnvE1j : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenCUDA/device-printf.cu b/clang/test/CIR/CodeGenCUDA/device-printf.cu
index 7d9ac203600ac..3ded390570970 100644
--- a/clang/test/CIR/CodeGenCUDA/device-printf.cu
+++ b/clang/test/CIR/CodeGenCUDA/device-printf.cu
@@ -17,7 +17,7 @@ __device__ void print_int() {
}
// CIR: cir.func no_inline dso_local @_Z9print_intv()
-// CIR: %[[#ALLOCA:]] = cir.alloca !rec_anon_struct
+// CIR: %[[#ALLOCA:]] = cir.alloca {{.*}} !rec_anon_struct
// CIR: %[[#VAL:]] = cir.const #cir.int<42> : !s32i
// CIR: %[[#FIELD:]] = cir.get_member %[[#ALLOCA]][0]
// CIR: cir.store align(4) %[[#VAL]], %[[#FIELD]]
diff --git a/clang/test/CIR/CodeGenCUDA/kernel-call.cu b/clang/test/CIR/CodeGenCUDA/kernel-call.cu
index 924f26c6dafbc..cf0e908859e09 100644
--- a/clang/test/CIR/CodeGenCUDA/kernel-call.cu
+++ b/clang/test/CIR/CodeGenCUDA/kernel-call.cu
@@ -31,11 +31,11 @@
// CUDA-NEW-LABEL: cir.func {{.*}} @_Z21__device_stub__kernelif
//
// Check kernel arguments are allocated as local variables
-// CUDA-NEW-DAG: cir.alloca !s32i, {{.*}} ["x", init]
-// CUDA-NEW-DAG: cir.alloca !cir.float, {{.*}} ["y", init]
+// CUDA-NEW-DAG: cir.alloca "x" {{.*}} init !s32i
+// CUDA-NEW-DAG: cir.alloca "y" {{.*}} init !cir.float
//
// Check void *args[] array is created with correct size (2 args)
-// CUDA-NEW: cir.alloca !cir.array<!cir.ptr<!void> x 2>, {{.*}} ["kernel_args"]
+// CUDA-NEW: cir.alloca "kernel_args" {{.*}} !cir.array<!cir.ptr<!void> x 2>
// CUDA-NEW: cir.cast array_to_ptrdecay
//
// Check arguments are stored in the args array via ptr_stride indexing
@@ -49,12 +49,12 @@
// CUDA-NEW: cir.store {{.*}} !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
//
// Check dim3 grid_dim and block_dim allocas for launch configuration
-// CUDA-NEW-DAG: cir.alloca !rec_dim3, {{.*}} ["grid_dim"]
-// CUDA-NEW-DAG: cir.alloca !rec_dim3, {{.*}} ["block_dim"]
+// CUDA-NEW-DAG: cir.alloca "grid_dim" {{.*}} !rec_dim3
+// CUDA-NEW-DAG: cir.alloca "block_dim" {{.*}} !rec_dim3
//
// Check shared_mem (size_t) and stream allocas
-// CUDA-NEW-DAG: cir.alloca !u64i, {{.*}} ["shared_mem"]
-// CUDA-NEW-DAG: cir.alloca !cir.ptr<!rec_cudaStream>, {{.*}} ["stream"]
+// CUDA-NEW-DAG: cir.alloca "shared_mem" {{.*}} !u64i
+// CUDA-NEW-DAG: cir.alloca "stream" {{.*}} !cir.ptr<!rec_cudaStream>
//
// Check __cudaPopCallConfiguration is called with correct argument types
// CUDA-NEW: cir.call @__cudaPopCallConfiguration({{.*}}) : (!cir.ptr<!rec_dim3>, !cir.ptr<!rec_dim3>, !cir.ptr<!u64i>, !cir.ptr<!cir.ptr<!rec_cudaStream>>) -> !s32i
@@ -68,7 +68,7 @@
//
// HIP-NEW: cir.global constant external @_Z6kernelif = #cir.global_view<@_Z21__device_stub__kernelif> : !cir.ptr<!cir.func<(!s32i, !cir.float)>> {alignment = 8 : i64}
// HIP-NEW-LABEL: cir.func {{.*}} @_Z21__device_stub__kernelif
-// HIP-NEW: cir.alloca !cir.ptr<!rec_hipStream>, {{.*}} ["stream"]
+// HIP-NEW: cir.alloca "stream" {{.*}} !cir.ptr<!rec_hipStream>
// HIP-NEW: cir.call @__hipPopCallConfiguration({{.*}}) : (!cir.ptr<!rec_dim3>, !cir.ptr<!rec_dim3>, !cir.ptr<!u64i>, !cir.ptr<!cir.ptr<!rec_hipStream>>) -> !s32i
// HIP-NEW: cir.get_global @_Z6kernelif : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float)>>>
// HIP-NEW: cir.call @hipLaunchKernel({{.*}}) : (!cir.ptr<!void> {{.*}}, !rec_dim3, !rec_dim3, !cir.ptr<!cir.ptr<!void>>{{.*}}, !u64i{{.*}}, !cir.ptr<!rec_hipStream>{{.*}}) -> (!u32i {llvm.noundef})
@@ -88,10 +88,10 @@ __global__ void kernel(int x, float y) {}
// HIP-NEW-LABEL: cir.func {{.*}} @main
int main(void) {
// Check dim3 temporaries are allocated for grid and block dimensions
- // CUDA-NEW-DAG: cir.alloca !rec_dim3, {{.*}} ["agg.tmp0"]
- // CUDA-NEW-DAG: cir.alloca !rec_dim3, {{.*}} ["agg.tmp1"]
- // HIP-NEW-DAG: cir.alloca !rec_dim3, {{.*}} ["agg.tmp0"]
- // HIP-NEW-DAG: cir.alloca !rec_dim3, {{.*}} ["agg.tmp1"]
+ // CUDA-NEW-DAG: cir.alloca "agg.tmp0" {{.*}} !rec_dim3
+ // CUDA-NEW-DAG: cir.alloca "agg.tmp1" {{.*}} !rec_dim3
+ // HIP-NEW-DAG: cir.alloca "agg.tmp0" {{.*}} !rec_dim3
+ // HIP-NEW-DAG: cir.alloca "agg.tmp1" {{.*}} !rec_dim3
//
// Check dim3 constructors are called for grid and block dimensions
// CUDA-NEW: cir.call @_ZN4dim3C1Ejjj({{.*}}) : (!cir.ptr<!rec_dim3> {llvm.align = 4 : i64, llvm.dereferenceable = 12 : i64, llvm.nonnull, llvm.noundef}, !u32i {llvm.noundef}, !u32i {llvm.noundef}, !u32i {llvm.noundef}) -> ()
diff --git a/clang/test/CIR/CodeGenCXX/global-refs.cpp b/clang/test/CIR/CodeGenCXX/global-refs.cpp
index 38cc9bf7daa46..470c052f751d6 100644
--- a/clang/test/CIR/CodeGenCXX/global-refs.cpp
+++ b/clang/test/CIR/CodeGenCXX/global-refs.cpp
@@ -133,7 +133,7 @@ void use() {
// CIR-LABEL: cir.func{{.*}}use
WithCtor &local = ExternRef;
- // CIR-NEXT: %[[LOCAL:.*]] = cir.alloca !cir.ptr<!rec_WithCtor>, !cir.ptr<!cir.ptr<!rec_WithCtor>>, ["local", init, const]
+ // CIR-NEXT: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} init const !cir.ptr<!rec_WithCtor> -> !cir.ptr<!cir.ptr<!rec_WithCtor>>
// CIR-NEXT: %[[EXT_REF:.*]] = cir.get_global @ExternRef : !cir.ptr<!cir.ptr<!rec_WithCtor>>
// CIR-NEXT: %[[EXT_REF_LOAD:.*]] = cir.load %[[EXT_REF]] : !cir.ptr<!cir.ptr<!rec_WithCtor>>, !cir.ptr<!rec_WithCtor>
// CIR-NEXT: cir.store{{.*}}%[[EXT_REF_LOAD]], %[[LOCAL]]
diff --git a/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp b/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp
index 961430a1a3fb9..565cafa568f19 100644
--- a/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp
+++ b/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp
@@ -30,7 +30,7 @@ struct Struct{Struct(); Struct(int);};
Struct s;
template void templ<s>();
// CIR: cir.func{{.*}}@_Z5templITnRDaL_Z1sEEvv()
-// CIR-NEXT: %[[TEMP:.*]] = cir.alloca !rec_Struct, !cir.ptr<!rec_Struct>
+// CIR-NEXT: %[[TEMP:.*]] = cir.alloca {{.*}} !rec_Struct -> !cir.ptr<!rec_Struct>
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR-NEXT: cir.call @_ZN6StructC1Ei(%[[TEMP]], %[[ONE]])
// CIR-NEXT: %[[GLOB:.*]] = cir.get_global @s : !cir.ptr<!rec_Struct>
diff --git a/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp b/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp
index 81e9e96391fd7..7204826f9b666 100644
--- a/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp
+++ b/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp
@@ -27,7 +27,7 @@ void cleanup_const_exact() { new Throws[3]{1, 2, 3}; }
// call we update arrayinit.endOfInit so the EH cleanup destroys only the
// elements that were actually constructed before the throw.
// CIR-LABEL: cir.func{{.*}} @_Z19cleanup_const_exactv(
-// CIR: %[[INIT_END:.*]] = cir.alloca {{.*}}, !cir.ptr<!cir.ptr<!rec_Throws>>, ["arrayinit.endOfInit"]
+// CIR: %[[INIT_END:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} {{.*}} -> !cir.ptr<!cir.ptr<!rec_Throws>>
// CIR: %[[ELT0:.*]] = cir.cast bitcast %{{.*}} : !cir.ptr<!void> -> !cir.ptr<!rec_Throws>
// CIR: cir.cleanup.scope {
// CIR: cir.store align(8) %[[ELT0]], %[[INIT_END]]
@@ -130,7 +130,7 @@ void cleanup_const_exact() { new Throws[3]{1, 2, 3}; }
void cleanup_const_partial() { new Throws[5]{1, 2, 3}; }
// CIR-LABEL: cir.func{{.*}} @_Z21cleanup_const_partialv(
-// CIR: %[[INIT_END:.*]] = cir.alloca {{.*}}, !cir.ptr<!cir.ptr<!rec_Throws>>, ["arrayinit.endOfInit"]
+// CIR: %[[INIT_END:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} {{.*}} -> !cir.ptr<!cir.ptr<!rec_Throws>>
// CIR: %[[ELT0:.*]] = cir.cast bitcast %{{.*}} : !cir.ptr<!void> -> !cir.ptr<!rec_Throws>
// CIR: cir.cleanup.scope {
// CIR: cir.store align(8) %[[ELT0]], %[[INIT_END]]
diff --git a/clang/test/CIR/CodeGenCXX/new-array-init.cpp b/clang/test/CIR/CodeGenCXX/new-array-init.cpp
index 512603efa3138..8374fe1d760f1 100644
--- a/clang/test/CIR/CodeGenCXX/new-array-init.cpp
+++ b/clang/test/CIR/CodeGenCXX/new-array-init.cpp
@@ -16,7 +16,7 @@
// CIR-LABEL: cir.func{{.*}} @_Z2fni(
// CHECK-LABEL: define{{.*}} void @_Z2fni
void fn(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>
// CIR: %[[N_U64_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
@@ -71,7 +71,7 @@ void fn(int n) {
// CIR-LABEL: cir.func {{.*}}@_Z8fn_pareni(
// LLVM-LABEL: define{{.*}} void @_Z8fn_pareni
void fn_paren(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>
// CIR: %[[N_U64_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
@@ -280,7 +280,7 @@ void const_sufficient_paren() {
// CIR-LABEL: cir.func {{.*}}@_Z15string_nonconsti(
// LLVM-LABEL: define{{.*}} void @_Z15string_nonconsti
void string_nonconst(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init] {alignment = 4 : i64}
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
@@ -316,7 +316,7 @@ void string_nonconst(int n) {
// CIR-LABEL: cir.func no_inline dso_local @_Z21string_nonconst_pareni(
// LLVM-LABEL: define{{.*}} void @_Z21string_nonconst_pareni
void string_nonconst_paren(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init] {alignment = 4 : i64}
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
@@ -352,7 +352,7 @@ void string_nonconst_paren(int n) {
// CIR-LABEL: cir.func {{.*}}@_Z33string_nonconst_paren_extra_pareni(
// LLVM-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni
void string_nonconst_paren_extra_paren(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init] {alignment = 4 : i64}
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
@@ -508,7 +508,7 @@ void aggr_exact() {
// CIR-LABEL: cir.func {{.*}}@_Z15aggr_sufficienti(
// LLVM-LABEL: define{{.*}} void @_Z15aggr_sufficienti
void aggr_sufficient(int n) {
- // CIR: %[[ARG:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init] {alignment = 4 : i64}
+ // CIR: %[[ARG:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: %[[GET_N:.*]] = cir.load {{.*}}%[[ARG:.*]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[GET_N]] : !s32i -> !u64i
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !u64i
diff --git a/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp b/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp
index fe0fc64a6c399..c699b43ddc2c3 100644
--- a/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp
+++ b/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp
@@ -8,7 +8,7 @@ void test_const_cast(const S &s) {
const_cast<S&>(s).do_thing();
}
// CIR: cir.func {{.*}}@_Z15test_const_castRK1S(%[[ARG:.*]]: !cir.ptr<!rec_S>{{.*}}) {{.*}}{
-// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init, const]
+// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
// CIR-NEXT: cir.store %[[ARG]], %[[ARG_ALLOCA]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR-NEXT: %[[ARG_LOAD:.*]] = cir.load %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR-NEXT: cir.call @_ZN1S8do_thingEv(%[[ARG_LOAD]])
@@ -26,7 +26,7 @@ void test_reinterpet_cast(void *&data) {
call_with_ri_cast(reinterpret_cast<int*&>(data));
}
// CIR: cir.func {{.*}}@_Z20test_reinterpet_castRPv(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!void>>{{.*}}) {{.*}}{
-// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, ["data", init, const]
+// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca "data" {{.*}} init const !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
// CIR-NEXT: cir.store %[[ARG]], %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
// CIR-NEXT: %[[ARG_LOAD:.*]] = cir.load %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: %[[RI_CAST:.*]] = cir.cast bitcast %[[ARG_LOAD]] : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!rec_S>>
diff --git a/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp b/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp
index fcaec6e9ac7db..881bdf5ded3ee 100644
--- a/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp
+++ b/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp
@@ -32,8 +32,8 @@ void test() {
// LLVM-DAG: @__const._Z3fooIJEEDav.values = private constant [1 x i32] zeroinitializer
// CIR: cir.func {{.*}}@_Z3fooIJEEDav()
-// CIR: %[[RETVAL:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["__retval"]
-// CIR: %[[VAL_ARR:.*]] = cir.alloca !cir.array<!s32i x 1>, !cir.ptr<!cir.array<!s32i x 1>>, ["values", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[VAL_ARR:.*]] = cir.alloca "values" {{.*}} init !cir.array<!s32i x 1> -> !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[GET_GLOB_VAL:.*]] = cir.get_global @__const._Z3fooIJEEDav.values : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: cir.copy %[[GET_GLOB_VAL]] to %[[VAL_ARR]] : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
@@ -55,8 +55,8 @@ void test() {
// OGCG: ret i64 0
// CIR: cir.func {{.*}}@_Z3fooIJ2S12S22S3EEDav()
-// CIR: %[[RETVAL:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["__retval"]
-// CIR: %[[VAL_ARR:.*]] = cir.alloca !cir.array<!s32i x 4>, !cir.ptr<!cir.array<!s32i x 4>>, ["values", init]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[VAL_ARR:.*]] = cir.alloca "values" {{.*}} init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
// CIR: %[[GET_GLOB_VAL:.*]] = cir.get_global @__const._Z3fooIJ2S12S22S3EEDav.values : !cir.ptr<!cir.array<!s32i x 4>>
// CIR: cir.copy %[[GET_GLOB_VAL]] to %[[VAL_ARR]] : !cir.ptr<!cir.array<!s32i x 4>>
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
diff --git a/clang/test/CIR/CodeGenCXX/typeid.cpp b/clang/test/CIR/CodeGenCXX/typeid.cpp
index 82b1aad0d7dfd..7b42910235359 100644
--- a/clang/test/CIR/CodeGenCXX/typeid.cpp
+++ b/clang/test/CIR/CodeGenCXX/typeid.cpp
@@ -67,7 +67,7 @@ const std::type_info &A10_c_ti = typeid(char const[10]);
// LLVM-LABEL: define{{.*}} ptr @_ZN5Test11fEPv
// LLVM-SAME: personality ptr @__gxx_personality_v0
const char *f(void *arg) {
- // CIR: %[[ARG:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["arg", init]
+ // CIR: %[[ARG:.*]] = cir.alloca "arg" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
try {
// CIR: %[[ARG_VALUE:.*]] = cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR-NEXT: %[[ARG_CAST:.*]] = cir.cast bitcast %[[ARG_VALUE]] : !cir.ptr<!void> -> !cir.ptr<!rec_Test13A3AA>
diff --git a/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp b/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp
index e8f955c1d1cc9..111e68bda459c 100644
--- a/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp
+++ b/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp
@@ -27,7 +27,7 @@ extern constexpr Item items[] = {
};
// CIR-LABEL: cir.func {{.*}}@_ZTv0_n24_N1CD1Ev
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init]
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
// CIR: %[[THIS_CAST:.*]] = cir.cast bitcast %[[THIS_LOAD]] : !cir.ptr<!rec_C> -> !cir.ptr<!u8i>
// CIR: %[[VTBL_PTR:.*]] = cir.vtable.get_vptr %[[THIS_CAST]] : !cir.ptr<!u8i> -> !cir.ptr<!cir.vptr>
@@ -51,7 +51,7 @@ extern constexpr Item items[] = {
// LLVM: call void @_ZN1CD1Ev(ptr {{.*}}%[[APPLY_OFFSET]])
//
// CIR-LABEL: cir.func {{.*}}@_ZTv0_n24_N1CD0Ev
-// CIR: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init]
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
// CIR: %[[THIS_CAST:.*]] = cir.cast bitcast %[[THIS_LOAD]] : !cir.ptr<!rec_C> -> !cir.ptr<!u8i>
// CIR: %[[VTBL_PTR:.*]] = cir.vtable.get_vptr %[[THIS_CAST]] : !cir.ptr<!u8i> -> !cir.ptr<!cir.vptr>
diff --git a/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp b/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp
index f6267f05d2bc7..80fb7dad563c9 100644
--- a/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp
+++ b/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp
@@ -134,8 +134,8 @@ namespace test5 {
}
// CIR-LABEL: cir.func {{.*}} @_ZN5test51gEv
-// CIR: cir.alloca !rec_{{.*}}Y
-// CIR: cir.alloca !rec_{{.*}}X
+// CIR: cir.alloca {{.*}} !rec_{{.*}}Y
+// CIR: cir.alloca {{.*}} !rec_{{.*}}X
// CIR: cir.call @_ZN5test54getXEv
// CIR: cir.call @_ZN5test51X1fEv
// CIR: cir.call @_ZN5test55takeYERKNS_1YEi
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp
index 687cbd73e16fc..a8ecc8dfe4a3c 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp
@@ -9,10 +9,10 @@ struct HasOps {
void use(int x, int v, float f, HasOps ops) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[V_ARG:.*]]: !s32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}, %[[OPS_ARG:.*]]: !rec_HasOps{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
- // CHECK-NEXT: %[[V_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["v", init]
- // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
- // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca !rec_HasOps, !cir.ptr<!rec_HasOps>, ["ops", init]
+ // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[V_ALLOCA:.*]] = cir.alloca "v" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca "ops" {{.*}} init !rec_HasOps -> !cir.ptr<!rec_HasOps>
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[V_ARG]], %[[V_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[F_ARG]], %[[F_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
@@ -26,7 +26,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -43,7 +43,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -62,7 +62,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -79,7 +79,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -97,7 +97,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -121,7 +121,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -145,7 +145,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -170,7 +170,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -195,7 +195,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -223,7 +223,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -250,7 +250,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -275,7 +275,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -302,7 +302,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -342,7 +342,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -363,7 +363,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -383,7 +383,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -404,7 +404,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -426,7 +426,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -447,7 +447,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -467,7 +467,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -488,7 +488,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp
index af87aaaea95d6..84306f9a42d2a 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp
@@ -2,9 +2,9 @@
void use(int x, unsigned int y, float f) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[Y_ARG:.*]]: !u32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}{
- // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
- // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["y", init]
- // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
+ // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca "y" {{.*}} init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOC]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[Y_ARG]], %[[Y_ALLOC]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[F_ARG]], %[[F_ALLOC]] : !cir.float, !cir.ptr<!cir.float>
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp
index 65db274222d6a..de49ec6cf7239 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp
@@ -7,10 +7,10 @@ struct HasOps {
void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[Y_ARG:.*]]: !u32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}, %[[OPS_ARG:.*]]: !rec_HasOps{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
- // CHECK-NEXT: %[[Y_ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["y", init]
- // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
- // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca !rec_HasOps, !cir.ptr<!rec_HasOps>, ["ops", init]
+ // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[Y_ALLOCA:.*]] = cir.alloca "y" {{.*}} init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca "ops" {{.*}} init !rec_HasOps -> !cir.ptr<!rec_HasOps>
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[Y_ARG]], %[[Y_ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[F_ARG]], %[[F_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
@@ -18,7 +18,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!s32i>, !s32i
@@ -33,7 +33,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[Y_ALLOCA]] : !cir.ptr<!u32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !u32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !u32i, !cir.ptr<!u32i>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!u32i>, !u32i
@@ -48,7 +48,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[F_ALLOCA]] : !cir.ptr<!cir.float> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !cir.float{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -63,7 +63,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -81,7 +81,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[F_ALLOCA]] : !cir.ptr<!cir.float> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !cir.float{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
//
// CHECK-NEXT: %[[Y_LOAD:.*]] = cir.load{{.*}} %[[Y_ALLOCA]] : !cir.ptr<!u32i>, !u32i
@@ -98,7 +98,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[Y_ALLOCA]] : !cir.ptr<!u32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !u32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !u32i, !cir.ptr<!u32i>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!u32i>, !u32i
@@ -116,7 +116,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[CALL:.*]] = cir.call {{.*}}(%[[OPS_ALLOCA]]) : (!cir.ptr<!rec_HasOps> {{.*}}) -> (!s32i{{.*}})
@@ -135,7 +135,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: %[[X_CAST:.*]] = builtin.unrealized_conversion_cast %[[BOOL_CAST]] : !cir.bool to i1
// CHECK-NEXT: acc.atomic.update if(%[[X_CAST]]) %[[F_ALLOCA]] : !cir.ptr<!cir.float> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !cir.float{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["x_var", init]
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp
index 8c903ac8ce8eb..c2bbbb670cd75 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp
@@ -9,10 +9,10 @@ struct ConvertsToScalar {
void use(int x, unsigned int y, float f, ConvertsToScalar cts) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[Y_ARG:.*]]: !u32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}, %[[CTS_ARG:.*]]: !rec_ConvertsToScalar{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
- // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["y", init]
- // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f", init]
- // CHECK-NEXT: %[[CTS_ALLOC:.*]] = cir.alloca !rec_ConvertsToScalar, !cir.ptr<!rec_ConvertsToScalar>, ["cts", init]
+ // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca "y" {{.*}} init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[CTS_ALLOC:.*]] = cir.alloca "cts" {{.*}} init !rec_ConvertsToScalar -> !cir.ptr<!rec_ConvertsToScalar>
//
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOC]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[Y_ARG]], %[[Y_ALLOC]] : !u32i, !cir.ptr<!u32i>
diff --git a/clang/test/CIR/CodeGenOpenACC/cache.c b/clang/test/CIR/CodeGenOpenACC/cache.c
index d82230a5e3841..98322ecb3d240 100644
--- a/clang/test/CIR/CodeGenOpenACC/cache.c
+++ b/clang/test/CIR/CodeGenOpenACC/cache.c
@@ -4,9 +4,9 @@ void acc_cache() {
// CHECK: cir.func{{.*}} @acc_cache()
int iArr[10];
- // CHECK-NEXT: %[[IARR:.*]] = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["iArr"]
+ // CHECK-NEXT: %[[IARR:.*]] = cir.alloca "iArr" {{.*}} !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
float fArr[10];
- // CHECK-NEXT: %[[FARR:.*]] = cir.alloca !cir.array<!cir.float x 10>, !cir.ptr<!cir.array<!cir.float x 10>>, ["fArr"]
+ // CHECK-NEXT: %[[FARR:.*]] = cir.alloca "fArr" {{.*}} !cir.array<!cir.float x 10> -> !cir.ptr<!cir.array<!cir.float x 10>>
#pragma acc cache(iArr[1], fArr[1:5])
// This does nothing, as it is not in a loop.
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copy.c b/clang/test/CIR/CodeGenOpenACC/combined-copy.c
index f16c25188bd1b..7e16dcf002bf6 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copy.c
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copy.c
@@ -3,17 +3,17 @@
int global;
void acc_compute(int parmVar) {
// CHECK: cir.func{{.*}} @acc_compute(%[[ARG:.*]]: !s32i{{.*}})
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
int localVar1;
short localVar2;
float localVar3;
- // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar1"]
- // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca !s16i, !cir.ptr<!s16i>, ["localVar2"]
- // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["localVar3"]
- // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>, ["localPointer"]
- // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["localArray"]
- // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.float> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>, ["localArrayOfPtrs"]
- // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>, ["threeDArray"]
+ // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca "localVar2" {{.*}} !s16i -> !cir.ptr<!s16i>
+ // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca "localVar3" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca "localPointer" {{.*}} !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
+ // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca "localArray" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca "localArrayOfPtrs" {{.*}} !cir.array<!cir.ptr<!cir.float> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>
+ // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca "threeDArray" {{.*}} !cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
#pragma acc parallel loop copy(localVar1, parmVar) copy(localVar2) copy(localVar3, parmVar)
@@ -773,7 +773,7 @@ typedef struct StructTy {
void acc_compute_members() {
// CHECK: cir.func{{.*}} @acc_compute_members()
Struct localStruct;
- // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca !rec_StructTy, !cir.ptr<!rec_StructTy>, ["localStruct"]
+ // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca "localStruct" {{.*}} !rec_StructTy -> !cir.ptr<!rec_StructTy>
#pragma acc parallel loop copy(localStruct)
for(int i = 0; i < 5; ++i);
@@ -1082,7 +1082,7 @@ typedef struct OuterTy {
void copy_member_of_array_element_member() {
// CHECK: cir.func{{.*}} @copy_member_of_array_element_member()
Outer outer;
- // CHECK-NEXT: %[[OUTER:.*]] = cir.alloca !rec_OuterTy, !cir.ptr<!rec_OuterTy>, ["outer"]
+ // CHECK-NEXT: %[[OUTER:.*]] = cir.alloca "outer" {{.*}} !rec_OuterTy -> !cir.ptr<!rec_OuterTy>
#pragma acc parallel loop copy(outer.inner[2].b)
for(int i = 0; i < 5; ++i);
@@ -1103,7 +1103,7 @@ void copy_member_of_array_element_member() {
void modifier_list() {
// CHECK: cir.func{{.*}} @modifier_list()
int localVar;
- // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar"]
+ // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca "localVar" {{.*}} !s32i -> !cir.ptr<!s32i>
#pragma acc parallel loop copy(always:localVar)
for(int i = 0; i < 5; ++i);
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp b/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp
index 525cf3de187e5..b6c4f2c5c9089 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp
@@ -11,7 +11,7 @@ struct StructTy {
void InlineFunc() {
// CHECK: cir.func {{.*}}InlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>, ["this", init]
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
@@ -221,7 +221,7 @@ void InlineUse() {
void StructTy::OutlineFunc() {
// CHECK: cir.func {{.*}}OutlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>, ["this", init]
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
#pragma acc parallel loop copy(scalarMember)
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c b/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c
index 666c3c16fa35e..7b6e9401521ef 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c
@@ -2,12 +2,12 @@
void acc_combined(int parmVar) {
// CHECK: cir.func{{.*}} @acc_combined(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
int localVar1;
- // CHECK-NEXT: %[[LV1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar1"]
+ // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
float localVar2;
- // CHECK-NEXT: %[[LV2:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["localVar2"]
+ // CHECK-NEXT: %[[LV2:.*]] = cir.alloca "localVar2" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]]
#pragma acc parallel loop copyin(parmVar) copyout(localVar1) create(localVar2)
for(int i = 0; i < 5; ++i);
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp b/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp
index a75c2fcab14e7..4c1ddb0d458c1 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp
@@ -21,7 +21,7 @@ struct HasDtor {
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -32,7 +32,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.float> {{.*}}):
@@ -43,7 +43,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
@@ -53,7 +53,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
@@ -63,7 +63,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
@@ -73,7 +73,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -87,7 +87,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -96,7 +96,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -123,7 +123,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -132,7 +132,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -159,7 +159,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -168,7 +168,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -194,7 +194,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -203,7 +203,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -229,7 +229,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -238,7 +238,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -264,7 +264,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -273,7 +273,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -302,7 +302,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -331,29 +331,29 @@ extern "C" void acc_combined() {
// CHECK: cir.func{{.*}} @acc_combined()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel loop firstprivate(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp b/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
index 5ad6a62c72663..f5d3086d1a661 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
@@ -18,35 +18,35 @@ struct HasDtor {
// Int
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// Float
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -54,7 +54,7 @@ struct HasDtor {
// HasDtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -65,41 +65,41 @@ struct HasDtor {
// int[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -124,7 +124,7 @@ struct HasDtor {
// HasDtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -133,7 +133,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -161,29 +161,29 @@ extern "C" void acc_combined() {
// CHECK: cir.func{{.*}} @acc_combined()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel loop private(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
index c3a787f32e085..94aba94f23f8c 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
@@ -24,7 +24,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -70,7 +70,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -116,7 +116,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -201,7 +201,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -286,7 +286,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -320,7 +320,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -354,7 +354,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -388,7 +388,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -472,7 +472,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -557,7 +557,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -565,7 +565,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -626,7 +626,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -634,7 +634,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -696,7 +696,7 @@ void acc_combined() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -704,7 +704,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -803,7 +803,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -811,7 +811,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -910,7 +910,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -918,7 +918,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -967,7 +967,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -975,7 +975,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1024,7 +1024,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1032,7 +1032,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1081,7 +1081,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1089,7 +1089,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1189,7 +1189,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1197,7 +1197,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1298,13 +1298,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1345,7 +1345,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1404,13 +1404,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1451,7 +1451,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1510,13 +1510,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1557,7 +1557,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1658,13 +1658,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1705,7 +1705,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1806,13 +1806,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,7 +1847,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1894,13 +1894,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,7 +1935,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1982,13 +1982,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,7 +2023,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2070,13 +2070,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2117,7 +2117,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2216,13 +2216,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2263,7 +2263,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp
index c96e9d9e0b16f..fb9d3d4e303a1 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp
@@ -8,7 +8,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -146,7 +146,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -176,7 +176,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -184,7 +184,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -214,7 +214,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -222,7 +222,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -259,7 +259,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -267,7 +267,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -304,7 +304,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -312,7 +312,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -352,7 +352,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -360,7 +360,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -401,13 +401,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -435,7 +435,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -465,13 +465,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -499,7 +499,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -529,13 +529,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -563,7 +563,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,13 +600,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -634,7 +634,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -671,13 +671,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -705,7 +705,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -745,13 +745,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -779,7 +779,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp
index d00b815a48f97..8c7efe8548a09 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp
@@ -28,7 +28,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -59,7 +59,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -90,7 +90,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -127,7 +127,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -164,7 +164,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -195,7 +195,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -226,7 +226,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -257,7 +257,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -289,7 +289,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -322,8 +322,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -359,7 +359,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -387,7 +387,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -407,7 +407,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -503,7 +503,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -530,7 +530,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -550,7 +550,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -646,7 +646,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -679,7 +679,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -699,7 +699,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -795,7 +795,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -828,7 +828,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -848,7 +848,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -944,7 +944,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -971,7 +971,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -991,8 +991,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1029,7 +1029,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1056,7 +1056,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1076,8 +1076,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1113,7 +1113,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1140,7 +1140,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1161,7 +1161,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1257,7 +1257,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1287,7 +1287,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1307,8 +1307,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1345,7 +1345,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1375,7 +1375,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1396,13 +1396,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1443,7 +1443,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1472,7 +1472,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1499,13 +1499,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1546,7 +1546,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1575,7 +1575,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1602,13 +1602,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1649,7 +1649,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1684,7 +1684,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1711,13 +1711,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1758,7 +1758,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1820,13 +1820,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1867,7 +1867,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1896,7 +1896,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1923,13 +1923,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1970,7 +1970,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1999,7 +1999,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2026,13 +2026,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2073,7 +2073,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2102,7 +2102,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2129,13 +2129,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2176,7 +2176,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2208,7 +2208,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2235,13 +2235,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2282,7 +2282,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2314,7 +2314,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp
index 6ae544b9430e3..7b6f5d5d4deff 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp
@@ -8,7 +8,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -104,7 +104,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -121,7 +121,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -164,7 +164,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -518,7 +518,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -526,7 +526,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -567,13 +567,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -601,7 +601,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -631,13 +631,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -665,7 +665,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -695,13 +695,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -729,7 +729,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -766,13 +766,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -800,7 +800,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -837,13 +837,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -871,7 +871,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -901,13 +901,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -935,7 +935,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -965,13 +965,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -999,7 +999,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1029,13 +1029,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1063,7 +1063,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1103,13 +1103,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1137,7 +1137,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp
index 3b2f0d560d55d..27d9e8fbc04f4 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp
@@ -27,7 +27,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -58,7 +58,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -126,7 +126,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -163,7 +163,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -194,7 +194,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -225,7 +225,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -256,7 +256,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -288,7 +288,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -321,8 +321,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -358,7 +358,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -386,7 +386,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -406,7 +406,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -502,7 +502,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -529,7 +529,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -549,7 +549,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -645,7 +645,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -678,7 +678,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -698,7 +698,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -794,7 +794,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -827,7 +827,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -847,7 +847,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -943,7 +943,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -970,7 +970,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -990,8 +990,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1028,7 +1028,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1055,7 +1055,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1075,8 +1075,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1112,7 +1112,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1139,7 +1139,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1160,7 +1160,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1256,7 +1256,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1286,7 +1286,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1306,8 +1306,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1344,7 +1344,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1374,7 +1374,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1395,13 +1395,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1442,7 +1442,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1471,7 +1471,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1498,13 +1498,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1545,7 +1545,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1574,7 +1574,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1601,13 +1601,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1648,7 +1648,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1683,7 +1683,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1710,13 +1710,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1757,7 +1757,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1792,7 +1792,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1819,13 +1819,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1866,7 +1866,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1895,7 +1895,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1922,13 +1922,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1969,7 +1969,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1998,7 +1998,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2025,13 +2025,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2072,7 +2072,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2101,7 +2101,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2128,13 +2128,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2175,7 +2175,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2207,7 +2207,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2234,13 +2234,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2281,7 +2281,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2313,7 +2313,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/combined.cpp b/clang/test/CIR/CodeGenOpenACC/combined.cpp
index f15078cb1469b..447e9443d7d15 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined.cpp
@@ -2,8 +2,8 @@
extern "C" void acc_combined(int N, int cond) {
// CHECK: cir.func{{.*}} @acc_combined(%[[ARG_N:.*]]: !s32i {{.*}}, %[[ARG_COND:.*]]: !s32i {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["N", init]
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca "N" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_N]], %[[ALLOCA_N]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_COND]], %[[COND]] : !s32i, !cir.ptr<!s32i>
@@ -1013,8 +1013,8 @@ extern "C" void acc_combined(int N, int cond) {
}
extern "C" void acc_combined_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_combined_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg1", init]
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg2", init]
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-copy.c b/clang/test/CIR/CodeGenOpenACC/compute-copy.c
index fd8b5ee3761c4..7c774000722c7 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-copy.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-copy.c
@@ -3,17 +3,17 @@
int global;
void acc_compute(int parmVar) {
// CHECK: cir.func{{.*}} @acc_compute(%[[ARG:.*]]: !s32i{{.*}})
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
int localVar1;
short localVar2;
float localVar3;
- // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar1"]
- // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca !s16i, !cir.ptr<!s16i>, ["localVar2"]
- // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["localVar3"]
- // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>, ["localPointer"]
- // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["localArray"]
- // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.float> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>, ["localArrayOfPtrs"]
- // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>, ["threeDArray"]
+ // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca "localVar2" {{.*}} !s16i -> !cir.ptr<!s16i>
+ // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca "localVar3" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca "localPointer" {{.*}} !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
+ // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca "localArray" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca "localArrayOfPtrs" {{.*}} !cir.array<!cir.ptr<!cir.float> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>
+ // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca "threeDArray" {{.*}} !cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
@@ -646,7 +646,7 @@ typedef struct StructTy {
void acc_compute_members() {
// CHECK: cir.func{{.*}} @acc_compute_members()
Struct localStruct;
- // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca !rec_StructTy, !cir.ptr<!rec_StructTy>, ["localStruct"]
+ // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca "localStruct" {{.*}} !rec_StructTy -> !cir.ptr<!rec_StructTy>
#pragma acc parallel copy(localStruct)
;
@@ -899,7 +899,7 @@ void acc_compute_members() {
void modifier_list() {
// CHECK: cir.func{{.*}} @modifier_list()
int localVar;
- // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar"]
+ // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca "localVar" {{.*}} !s32i -> !cir.ptr<!s32i>
#pragma acc parallel copy(always:localVar)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp b/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp
index e1692f5a5f3c8..bf742882cebe5 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp
@@ -11,7 +11,7 @@ struct StructTy {
void InlineFunc() {
// CHECK: cir.func {{.*}}InlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>, ["this", init]
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
@@ -185,7 +185,7 @@ void InlineUse() {
void StructTy::OutlineFunc() {
// CHECK: cir.func {{.*}}OutlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>, ["this", init]
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
#pragma acc parallel copy(scalarMember)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c b/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c
index c0684f0930e40..d5aeb982b7be4 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c
@@ -2,12 +2,12 @@
void acc_compute(int parmVar) {
// CHECK: cir.func{{.*}} @acc_compute(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
int localVar1;
- // CHECK-NEXT: %[[LV1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar1"]
+ // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
float localVar2;
- // CHECK-NEXT: %[[LV2:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["localVar2"]
+ // CHECK-NEXT: %[[LV2:.*]] = cir.alloca "localVar2" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]]
#pragma acc parallel copyin(parmVar) copyout(localVar1) create(localVar2)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp
index 853acad55f337..8801bdf420c68 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp
@@ -18,7 +18,7 @@ struct HasDtor {
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
@@ -28,7 +28,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
@@ -38,7 +38,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -52,7 +52,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -64,10 +64,10 @@ struct HasDtor {
template<typename T, typename U, typename V, typename W>
void dependent_version(const T &cc, const U &ndc, const V &dtor, const W &someInt) {
// CHECK: cir.func {{.*}}@_Z17dependent_versionI13CopyConstruct14NonDefaultCtor7HasDtoriEvRKT_RKT0_RKT1_RKT2_(%[[ARG0:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG2:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG3:.*]]: !cir.ptr<!s32i> {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[CC:.*]] = cir.alloca !cir.ptr<!rec_CopyConstruct>, !cir.ptr<!cir.ptr<!rec_CopyConstruct>>, ["cc", init, const]
- // CHECK-NEXT: %[[NDC:.*]] = cir.alloca !cir.ptr<!rec_NonDefaultCtor>, !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, ["ndc", init, const]
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>, ["dtor", init, const]
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["someInt", init, const]
+ // CHECK-NEXT: %[[CC:.*]] = cir.alloca "cc" {{.*}} init const !cir.ptr<!rec_CopyConstruct> -> !cir.ptr<!cir.ptr<!rec_CopyConstruct>>
+ // CHECK-NEXT: %[[NDC:.*]] = cir.alloca "ndc" {{.*}} init const !cir.ptr<!rec_NonDefaultCtor> -> !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} init const !cir.ptr<!rec_HasDtor> -> !cir.ptr<!cir.ptr<!rec_HasDtor>>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
#pragma acc parallel firstprivate(cc, ndc, dtor, someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c
index 953c894456d9a..a49819cfc67be 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c
@@ -4,7 +4,7 @@ struct NoCopyConstruct {};
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -15,7 +15,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.float> {{.*}}):
@@ -26,7 +26,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
@@ -36,7 +36,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -45,7 +45,7 @@ struct NoCopyConstruct {};
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -72,7 +72,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -81,7 +81,7 @@ struct NoCopyConstruct {};
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -108,7 +108,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -117,7 +117,7 @@ struct NoCopyConstruct {};
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -145,17 +145,17 @@ void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
struct NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
struct NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
#pragma acc parallel firstprivate(someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp
index 79966a39b339c..0fcbeefc1c473 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp
@@ -22,7 +22,7 @@ struct HasDtor {
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -33,7 +33,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.float> {{.*}}):
@@ -44,7 +44,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
@@ -54,7 +54,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
@@ -64,7 +64,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
@@ -74,7 +74,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -88,7 +88,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -97,7 +97,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -124,7 +124,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -133,7 +133,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -160,7 +160,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -169,7 +169,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -195,7 +195,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -204,7 +204,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -230,7 +230,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -239,7 +239,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -265,7 +265,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.firstprivate.init"]
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -274,7 +274,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -303,7 +303,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -332,29 +332,29 @@ extern "C" void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel firstprivate(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp b/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp
index fc2835d7ebda2..415a947c33968 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp
@@ -15,20 +15,20 @@ struct HasDtor {
// CHECK: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor> {{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -38,17 +38,17 @@ struct HasDtor {
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
template<typename T, typename U, typename V, typename W>
void dependent_version(const T &cc, const U &ndc, const V &dtor, const W &someInt) {
// CHECK: cir.func {{.*}}@_Z17dependent_versionI13CopyConstruct14NonDefaultCtor7HasDtoriEvRKT_RKT0_RKT1_RKT2_(%[[ARG0:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG2:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG3:.*]]: !cir.ptr<!s32i> {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[CC:.*]] = cir.alloca !cir.ptr<!rec_CopyConstruct>, !cir.ptr<!cir.ptr<!rec_CopyConstruct>>, ["cc", init, const]
- // CHECK-NEXT: %[[NDC:.*]] = cir.alloca !cir.ptr<!rec_NonDefaultCtor>, !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, ["ndc", init, const]
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>, !cir.ptr<!cir.ptr<!rec_HasDtor>>, ["dtor", init, const]
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["someInt", init, const]
+ // CHECK-NEXT: %[[CC:.*]] = cir.alloca "cc" {{.*}} init const !cir.ptr<!rec_CopyConstruct> -> !cir.ptr<!cir.ptr<!rec_CopyConstruct>>
+ // CHECK-NEXT: %[[NDC:.*]] = cir.alloca "ndc" {{.*}} init const !cir.ptr<!rec_NonDefaultCtor> -> !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} init const !cir.ptr<!rec_HasDtor> -> !cir.ptr<!cir.ptr<!rec_HasDtor>>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
#pragma acc parallel private(cc, ndc, dtor, someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c
index 2e5ad9f14ad4b..01d83ac0d03f7 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c
@@ -5,42 +5,42 @@ struct NoCopyConstruct {};
// int
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// int[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -48,17 +48,17 @@ void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
struct NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
struct NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
#pragma acc parallel private(someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
index a2d2c39d3087a..7ea62b5c94973 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
@@ -17,38 +17,38 @@ struct HasDtor {
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -58,37 +58,37 @@ struct HasDtor {
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -112,7 +112,7 @@ struct HasDtor {
//
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -121,7 +121,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -149,29 +149,29 @@ extern "C" void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel private(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
index 1257fef2615d9..d6a8e7eefa576 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
@@ -23,7 +23,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -70,7 +70,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, {{.*}}, #cir.fp<1{{.*}}> : !cir.double, #true, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -117,7 +117,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, {{.*}}, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -206,7 +206,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, {{.*}}, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -295,7 +295,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!rec_anon_struct1>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true, {{.*}}}> : !rec_anon_struct1
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct1, !cir.ptr<!rec_anon_struct1>
@@ -330,7 +330,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!rec_anon_struct1>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct1
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct1, !cir.ptr<!rec_anon_struct1>
@@ -365,7 +365,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!rec_anon_struct1>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct1
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct1, !cir.ptr<!rec_anon_struct1>
@@ -400,7 +400,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, {{.*}}, #cir.fp<1{{.*}}> : !cir.double, #true, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -488,7 +488,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -577,7 +577,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -585,7 +585,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -646,7 +646,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -654,7 +654,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -716,7 +716,7 @@ void acc_compute() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -724,7 +724,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -826,7 +826,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -834,7 +834,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -937,7 +937,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -945,7 +945,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -994,7 +994,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1002,7 +1002,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1051,7 +1051,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1059,7 +1059,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1108,7 +1108,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1116,7 +1116,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1219,7 +1219,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1227,7 +1227,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1331,13 +1331,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1378,7 +1378,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1437,13 +1437,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1484,7 +1484,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1543,13 +1543,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1590,7 +1590,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1695,13 +1695,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1742,7 +1742,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,13 +1847,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1888,7 +1888,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,13 +1935,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1976,7 +1976,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,13 +2023,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2064,7 +2064,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2111,13 +2111,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2158,7 +2158,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2260,13 +2260,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2307,7 +2307,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp
index dae634cd8bb58..2e738b34e2db3 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -70,7 +70,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -116,7 +116,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[LEAST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -201,7 +201,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[LARGEST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -286,7 +286,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -320,7 +320,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -354,7 +354,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -388,7 +388,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -472,7 +472,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -557,7 +557,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -565,7 +565,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -626,7 +626,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -634,7 +634,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -696,7 +696,7 @@ void acc_compute() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -704,7 +704,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -803,7 +803,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -811,7 +811,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -910,7 +910,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -918,7 +918,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -967,7 +967,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -975,7 +975,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1024,7 +1024,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1032,7 +1032,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1081,7 +1081,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1089,7 +1089,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1189,7 +1189,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1197,7 +1197,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1298,13 +1298,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1345,7 +1345,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1404,13 +1404,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1451,7 +1451,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1510,13 +1510,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1557,7 +1557,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1658,13 +1658,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1705,7 +1705,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1806,13 +1806,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,7 +1847,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1894,13 +1894,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,7 +1935,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1982,13 +1982,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,7 +2023,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2070,13 +2070,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2117,7 +2117,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2216,13 +2216,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2263,7 +2263,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
index 035c72424b68e..15d71c69b0e79 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
@@ -7,7 +7,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -40,7 +40,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -64,7 +64,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -87,7 +87,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -147,7 +147,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -177,7 +177,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -185,7 +185,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -215,7 +215,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -223,7 +223,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -260,7 +260,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -268,7 +268,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -305,7 +305,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -313,7 +313,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -354,7 +354,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -362,7 +362,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -404,13 +404,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -438,7 +438,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -468,13 +468,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -502,7 +502,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -532,13 +532,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -566,7 +566,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -603,13 +603,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -637,7 +637,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -674,13 +674,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -708,7 +708,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -749,13 +749,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -783,7 +783,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp
index 3b3beb395c74b..b556ea4b69337 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp
@@ -8,7 +8,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -146,7 +146,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -176,7 +176,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -184,7 +184,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -214,7 +214,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -222,7 +222,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -259,7 +259,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -267,7 +267,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -304,7 +304,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -312,7 +312,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -352,7 +352,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -360,7 +360,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -401,13 +401,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -435,7 +435,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -465,13 +465,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -499,7 +499,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -529,13 +529,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -563,7 +563,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,13 +600,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -634,7 +634,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -671,13 +671,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -705,7 +705,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -745,13 +745,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -779,7 +779,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp
index eae311958e90d..54d3799e18087 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp
@@ -28,7 +28,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -59,7 +59,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -90,7 +90,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -127,7 +127,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -164,7 +164,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -195,7 +195,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -226,7 +226,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -257,7 +257,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -289,7 +289,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -322,8 +322,8 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -359,7 +359,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -387,7 +387,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -407,7 +407,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -503,7 +503,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -530,7 +530,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -550,7 +550,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -646,7 +646,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -679,7 +679,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -699,7 +699,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -795,7 +795,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -828,7 +828,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -848,7 +848,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -944,7 +944,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -971,7 +971,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -991,8 +991,8 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1029,7 +1029,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1056,7 +1056,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1076,8 +1076,8 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1113,7 +1113,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1140,7 +1140,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1161,7 +1161,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1257,7 +1257,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1287,7 +1287,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1307,8 +1307,8 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1345,7 +1345,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1375,7 +1375,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1396,13 +1396,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1443,7 +1443,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1472,7 +1472,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1499,13 +1499,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1546,7 +1546,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1575,7 +1575,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1602,13 +1602,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1649,7 +1649,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1684,7 +1684,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1711,13 +1711,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1758,7 +1758,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1820,13 +1820,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1867,7 +1867,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1896,7 +1896,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1923,13 +1923,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1970,7 +1970,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1999,7 +1999,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2026,13 +2026,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2073,7 +2073,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2102,7 +2102,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2129,13 +2129,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2176,7 +2176,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2208,7 +2208,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2235,13 +2235,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2282,7 +2282,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2314,7 +2314,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
index 5a892c87cbd5b..69d370cb57af3 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
@@ -7,7 +7,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -41,7 +41,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -64,7 +64,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -87,7 +87,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -103,7 +103,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -120,7 +120,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -163,7 +163,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -189,7 +189,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -197,7 +197,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -227,7 +227,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -235,7 +235,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -265,7 +265,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -273,7 +273,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -310,7 +310,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -318,7 +318,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -355,7 +355,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -363,7 +363,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -393,7 +393,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -401,7 +401,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -431,7 +431,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -439,7 +439,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -469,7 +469,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -477,7 +477,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -517,7 +517,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -525,7 +525,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -566,13 +566,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,7 +600,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -630,13 +630,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -664,7 +664,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -694,13 +694,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -728,7 +728,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -765,13 +765,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -799,7 +799,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -836,13 +836,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -870,7 +870,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -900,13 +900,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -934,7 +934,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -964,13 +964,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -998,7 +998,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1028,13 +1028,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1062,7 +1062,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1102,13 +1102,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1136,7 +1136,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp
index 770fd189fb063..7ccf70372b6c5 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp
@@ -8,7 +8,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -104,7 +104,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -121,7 +121,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -164,7 +164,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5> loc(#loc12)
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>> loc(#loc12)
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5> loc(#loc12)
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>> loc(#loc12)
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -518,7 +518,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5> loc(#loc12)
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>> loc(#loc12)
// CHECK-NEXT: acc.yield
@@ -526,7 +526,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -567,13 +567,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -601,7 +601,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -631,13 +631,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -665,7 +665,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -695,13 +695,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -729,7 +729,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -766,13 +766,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -800,7 +800,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -837,13 +837,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -871,7 +871,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -901,13 +901,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -935,7 +935,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -965,13 +965,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -999,7 +999,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1029,13 +1029,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1063,7 +1063,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1103,13 +1103,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1137,7 +1137,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp
index 70bbcc8800406..0db0b6f3ecdcf 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp
@@ -27,7 +27,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -58,7 +58,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -126,7 +126,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -163,7 +163,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -194,7 +194,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -225,7 +225,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -256,7 +256,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -288,7 +288,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -321,8 +321,8 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -358,7 +358,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -386,7 +386,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -406,7 +406,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -502,7 +502,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -529,7 +529,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -549,7 +549,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -645,7 +645,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -678,7 +678,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -698,7 +698,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -794,7 +794,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -827,7 +827,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -847,7 +847,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -943,7 +943,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -970,7 +970,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -990,8 +990,8 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1028,7 +1028,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1055,7 +1055,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1075,8 +1075,8 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1112,7 +1112,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1139,7 +1139,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1160,7 +1160,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1256,7 +1256,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1286,7 +1286,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1306,8 +1306,8 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1344,7 +1344,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1374,7 +1374,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1395,13 +1395,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1442,7 +1442,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1471,7 +1471,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1498,13 +1498,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1545,7 +1545,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1574,7 +1574,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1601,13 +1601,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1648,7 +1648,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1683,7 +1683,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1710,13 +1710,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1757,7 +1757,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1792,7 +1792,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1819,13 +1819,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1866,7 +1866,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1895,7 +1895,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1922,13 +1922,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1969,7 +1969,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1998,7 +1998,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2025,13 +2025,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2072,7 +2072,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2101,7 +2101,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2128,13 +2128,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2175,7 +2175,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2207,7 +2207,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2234,13 +2234,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2281,7 +2281,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2313,7 +2313,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
index 60a077da4d862..3b890b902217e 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
@@ -7,7 +7,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSj : !cir.ptr<!u32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSj : !cir.ptr<!u32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -41,7 +41,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSj : !cir.ptr<!u32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -64,7 +64,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSj : !cir.ptr<!u32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -87,7 +87,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSj : !cir.ptr<!u32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -103,7 +103,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSj : !cir.ptr<!u32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -120,7 +120,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSj : !cir.ptr<!u32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -137,7 +137,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSj : !cir.ptr<!u32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -163,7 +163,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSj : !cir.ptr<!u32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -519,7 +519,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -527,7 +527,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -569,13 +569,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -603,7 +603,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -633,13 +633,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -667,7 +667,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -697,13 +697,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -731,7 +731,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -768,13 +768,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -802,7 +802,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -839,13 +839,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -873,7 +873,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -903,13 +903,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -937,7 +937,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -967,13 +967,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1001,7 +1001,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1031,13 +1031,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1065,7 +1065,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1106,13 +1106,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1140,7 +1140,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c b/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c
index bd85bfacf9636..9f369890f541e 100644
--- a/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c
+++ b/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c
@@ -2,9 +2,9 @@
void acc_data(int parmVar) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
int localVar1;
- // CHECK-NEXT: %[[LV1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["localVar1"]
+ // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]]
#pragma acc data copy(parmVar)
diff --git a/clang/test/CIR/CodeGenOpenACC/data.c b/clang/test/CIR/CodeGenOpenACC/data.c
index e5eb11a1aad2a..f2c32f50f4f3e 100644
--- a/clang/test/CIR/CodeGenOpenACC/data.c
+++ b/clang/test/CIR/CodeGenOpenACC/data.c
@@ -2,10 +2,10 @@
void acc_data(int cond) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
int *ptr;
- // CHECK-NEXT: %[[PTR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["ptr"]
+ // CHECK-NEXT: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc data default(none)
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
index 958dc4951de63..ebb0d4c8cc015 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
@@ -12,13 +12,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca "this" {{.*}}
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -76,13 +76,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca "this" {{.*}}
+// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -147,12 +147,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp
index 99d23a56a8aec..dffd21ef6b1f9 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp
@@ -260,13 +260,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -324,13 +324,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -395,12 +395,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp
index 5c3b453236c6b..69765e94f7e04 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp
@@ -12,13 +12,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -76,13 +76,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -147,12 +147,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-create.cpp b/clang/test/CIR/CodeGenOpenACC/declare-create.cpp
index 38a64c4a3795f..379a4d50425ec 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-create.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-create.cpp
@@ -261,13 +261,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -325,13 +325,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -396,12 +396,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp b/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
index f7559c8877b2e..7a777c6621f1a 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
@@ -12,11 +12,11 @@ struct Struct {
void MemFunc1(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}}, %[[ARG_INT:.*]]: !cir.ptr<!s32i> {{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSE
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>{{.*}}["ArgInt
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -47,11 +47,11 @@ void use() {
void Struct::MemFunc2(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}}, %[[ARG_INT:.*]]: !cir.ptr<!s32i> {{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSE
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>{{.*}}["ArgInt
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -88,10 +88,10 @@ extern "C" void do_thing();
void NormalFunc(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK: cir.func {{.*}}NormalFunc{{.*}}(%[[ARG_HSE:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}}, %[[ARG_INT:.*]]: !cir.ptr<!s32i> {{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSE
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>{{.*}}["ArgInt
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>{{.*}}["LocalInt
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}}
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
HasSideEffects *LocalHSE;
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp b/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp
index c34f887176cc3..7c286fc7579a0 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp
@@ -260,13 +260,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -324,13 +324,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -395,12 +395,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-link.cpp b/clang/test/CIR/CodeGenOpenACC/declare-link.cpp
index a96e815998b1d..44a7f0811184e 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-link.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-link.cpp
@@ -118,7 +118,7 @@ struct Struct {
void MemFunc1() {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}({{.*}}) {{.*}}{
- // CHECK-NEXT: cir.alloca{{.*}}["this"
+ // CHECK-NEXT: cir.alloca "this"
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.load
extern HasSideEffects LocalHSE;
@@ -161,7 +161,7 @@ void use() {
void Struct::MemFunc2() {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}({{.*}}) {{.*}}{
- // CHECK-NEXT: cir.alloca{{.*}}["this"
+ // CHECK-NEXT: cir.alloca "this"
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.load
extern HasSideEffects LocalHSE2;
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-present.cpp b/clang/test/CIR/CodeGenOpenACC/declare-present.cpp
index b4e238101d096..30996cadcdd09 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-present.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-present.cpp
@@ -13,13 +13,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: cir.alloca "this"
+// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -77,13 +77,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca{{.*}}["this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+// CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -148,12 +148,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["ArgHSE"
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["ArgInt
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_HasSideEffects>{{.*}}["ArgHSEPtr"
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca !rec_HasSideEffects{{.*}}["LocalHSE
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasSideEffects x 5>{{.*}}["LocalHSEArr
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca !s32i{{.*}}["LocalInt
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/enter-data.c b/clang/test/CIR/CodeGenOpenACC/enter-data.c
index d700e190f845d..41b43ed9ee70c 100644
--- a/clang/test/CIR/CodeGenOpenACC/enter-data.c
+++ b/clang/test/CIR/CodeGenOpenACC/enter-data.c
@@ -1,8 +1,8 @@
// RUN: %clang_cc1 -fopenacc -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir %s -o - | FileCheck %s
void acc_data(int parmVar, int *ptrParmVar) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}, %[[PTRARG:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
- // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["ptrParmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[PTRARG]], %[[PTRPARM]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/exit-data.c b/clang/test/CIR/CodeGenOpenACC/exit-data.c
index f1b559d58c8cd..05c6141529ea7 100644
--- a/clang/test/CIR/CodeGenOpenACC/exit-data.c
+++ b/clang/test/CIR/CodeGenOpenACC/exit-data.c
@@ -1,8 +1,8 @@
// RUN: %clang_cc1 -fopenacc -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir %s -o - | FileCheck %s
void acc_data(int parmVar, int *ptrParmVar) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}, %[[PTRARG:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
- // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["ptrParmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[PTRARG]], %[[PTRPARM]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp b/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp
index c8eda96ed7649..b56302e1750a0 100644
--- a/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp
@@ -20,7 +20,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel firstprivate(ThreeArr[B][B][B])
// CHECK:acc.firstprivate.recipe @firstprivatization__Bcnt3__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>, ["openacc.firstprivate.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -29,7 +29,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -46,7 +46,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -63,7 +63,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -108,7 +108,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB3_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -125,7 +125,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -142,7 +142,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -187,15 +187,15 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel firstprivate(ThreePtr[B][B][A:B])
// CHECK: acc.firstprivate.recipe @firstprivatization__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.firstprivate.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -225,12 +225,12 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -259,11 +259,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -295,7 +295,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -313,7 +313,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -330,7 +330,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -376,7 +376,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -394,7 +394,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -411,7 +411,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -458,15 +458,15 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel firstprivate(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt3__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>, ["openacc.firstprivate.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_CtorDtor> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -502,10 +502,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -534,7 +534,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -551,7 +551,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -568,7 +568,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -613,7 +613,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -631,7 +631,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -648,7 +648,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/host_data.c b/clang/test/CIR/CodeGenOpenACC/host_data.c
index 65fabda80e0cb..dd0fdbffa51e9 100644
--- a/clang/test/CIR/CodeGenOpenACC/host_data.c
+++ b/clang/test/CIR/CodeGenOpenACC/host_data.c
@@ -2,10 +2,10 @@
void acc_host_data(int cond, int var1, int var2, int *arr) {
// CHECK: cir.func{{.*}} @acc_host_data(%[[ARG_COND:.*]]: !s32i {{.*}}, %[[ARG_V1:.*]]: !s32i {{.*}}, %[[ARG_V2:.*]]: !s32i {{.*}}, %[[ARG_ARR:.*]]: !cir.ptr<!s32i> {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
- // CHECK-NEXT: %[[V1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["var1", init]
- // CHECK-NEXT: %[[V2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["var2", init]
- // CHECK-NEXT: %[[ARR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arr", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[V1:.*]] = cir.alloca "var1" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[V2:.*]] = cir.alloca "var2" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG_COND]], %[[COND]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_V1]], %[[V1]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_V2]], %[[V2]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenACC/init.c b/clang/test/CIR/CodeGenOpenACC/init.c
index 871645d1e280d..fad0009af08f7 100644
--- a/clang/test/CIR/CodeGenOpenACC/init.c
+++ b/clang/test/CIR/CodeGenOpenACC/init.c
@@ -2,7 +2,7 @@
void acc_init(int cond) {
// CHECK: cir.func{{.*}} @acc_init(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc init
// CHECK-NEXT: acc.init loc(#{{[a-zA-Z0-9]+}}){{$}}
diff --git a/clang/test/CIR/CodeGenOpenACC/kernels.c b/clang/test/CIR/CodeGenOpenACC/kernels.c
index 4ce98a2b5defa..f85d5308576ff 100644
--- a/clang/test/CIR/CodeGenOpenACC/kernels.c
+++ b/clang/test/CIR/CodeGenOpenACC/kernels.c
@@ -2,7 +2,7 @@
void acc_kernels(int cond) {
// CHECK: cir.func{{.*}} @acc_kernels(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc kernels
{}
@@ -419,8 +419,8 @@ void acc_kernels(int cond) {
void acc_kernels_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_kernels_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg1", init]
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg2", init]
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp b/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
index e402214c1f92b..816b22e5e869e 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
@@ -18,35 +18,35 @@ struct HasDtor {
// int
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["openacc.private.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -54,7 +54,7 @@ struct HasDtor {
// HasDtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -65,41 +65,41 @@ struct HasDtor {
// int[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -124,7 +124,7 @@ struct HasDtor {
// HasDtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -133,7 +133,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -161,29 +161,29 @@ extern "C" void acc_loop() {
// CHECK: cir.func{{.*}} @acc_loop()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["someInt"]
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["someFloat"]
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca !rec_NoCopyConstruct, !cir.ptr<!rec_NoCopyConstruct>, ["noCopy"]
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca !rec_CopyConstruct, !cir.ptr<!rec_CopyConstruct>, ["hasCopy"]
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca !rec_NonDefaultCtor, !cir.ptr<!rec_NonDefaultCtor>, ["notDefCtor", init]
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca !rec_HasDtor, !cir.ptr<!rec_HasDtor>, ["dtor"]
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["someIntArr"]
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["someFloatArr"]
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca !cir.array<!rec_NoCopyConstruct x 5>, !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>, ["noCopyArr"]
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca !cir.array<!rec_CopyConstruct x 5>, !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>, ["hasCopyArr"]
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x 5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["notDefCtorArr", init]
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca !cir.array<!rec_HasDtor x 5>, !cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["dtorArr"]
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc loop private(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp
index b112571bf1f94..f10b2afbca002 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp
@@ -24,7 +24,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -70,7 +70,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -116,7 +116,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -201,7 +201,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -286,7 +286,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -320,7 +320,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -354,7 +354,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -388,7 +388,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -472,7 +472,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -557,7 +557,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -565,7 +565,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -626,7 +626,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -634,7 +634,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -696,7 +696,7 @@ void acc_loop() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -704,7 +704,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -803,7 +803,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -811,7 +811,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -910,7 +910,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -918,7 +918,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -967,7 +967,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -975,7 +975,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1024,7 +1024,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1032,7 +1032,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1081,7 +1081,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1089,7 +1089,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1189,7 +1189,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1197,7 +1197,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1298,13 +1298,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1345,7 +1345,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1404,13 +1404,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1451,7 +1451,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1510,13 +1510,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1557,7 +1557,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1658,13 +1658,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1705,7 +1705,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1806,13 +1806,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,7 +1847,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1894,13 +1894,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,7 +1935,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1982,13 +1982,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,7 +2023,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2070,13 +2070,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2117,7 +2117,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2216,13 +2216,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2263,7 +2263,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp
index 9eda370bafbdb..6a2ba138e6246 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp
@@ -8,7 +8,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -146,7 +146,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -176,7 +176,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -184,7 +184,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -214,7 +214,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -222,7 +222,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -259,7 +259,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -267,7 +267,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -304,7 +304,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -312,7 +312,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -352,7 +352,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -360,7 +360,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -401,13 +401,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -435,7 +435,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -465,13 +465,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -499,7 +499,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -529,13 +529,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -563,7 +563,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,13 +600,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -634,7 +634,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -671,13 +671,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -705,7 +705,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -745,13 +745,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -779,7 +779,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp
index ed94790deb298..95e593bd485f9 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp
@@ -28,7 +28,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -59,7 +59,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -90,7 +90,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -127,7 +127,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -164,7 +164,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -195,7 +195,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -226,7 +226,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -257,7 +257,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -289,7 +289,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsInline, !cir.ptr<!rec_HasOperatorsInline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -322,8 +322,8 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -359,7 +359,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -387,7 +387,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -407,7 +407,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -503,7 +503,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -530,7 +530,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -550,7 +550,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -646,7 +646,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -679,7 +679,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -699,7 +699,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -795,7 +795,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -828,7 +828,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -848,7 +848,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -944,7 +944,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -971,7 +971,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -991,8 +991,8 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1029,7 +1029,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1056,7 +1056,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1076,8 +1076,8 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1113,7 +1113,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1140,7 +1140,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1161,7 +1161,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1257,7 +1257,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1287,7 +1287,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1307,8 +1307,8 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1345,7 +1345,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1375,7 +1375,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1396,13 +1396,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1443,7 +1443,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1472,7 +1472,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1499,13 +1499,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1546,7 +1546,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1575,7 +1575,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1602,13 +1602,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1649,7 +1649,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1684,7 +1684,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1711,13 +1711,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1758,7 +1758,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1820,13 +1820,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1867,7 +1867,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1896,7 +1896,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1923,13 +1923,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1970,7 +1970,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1999,7 +1999,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2026,13 +2026,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2073,7 +2073,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2102,7 +2102,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2129,13 +2129,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2176,7 +2176,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2208,7 +2208,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2235,13 +2235,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsInline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2282,7 +2282,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2314,7 +2314,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp
index 5ff18e0a6de84..5d1494efafd9c 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp
@@ -8,7 +8,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -104,7 +104,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -121,7 +121,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -164,7 +164,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -518,7 +518,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -526,7 +526,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -567,13 +567,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -601,7 +601,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -631,13 +631,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -665,7 +665,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -695,13 +695,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -729,7 +729,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -766,13 +766,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -800,7 +800,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"]
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -837,13 +837,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -871,7 +871,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -901,13 +901,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -935,7 +935,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -965,13 +965,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -999,7 +999,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1029,13 +1029,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1063,7 +1063,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1103,13 +1103,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1137,7 +1137,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp
index a338305a33b96..61f13150a1180 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp
@@ -27,7 +27,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -58,7 +58,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -126,7 +126,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -163,7 +163,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -194,7 +194,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -225,7 +225,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -256,7 +256,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -288,7 +288,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_HasOperatorsOutline, !cir.ptr<!rec_HasOperatorsOutline>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -321,8 +321,8 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -358,7 +358,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -386,7 +386,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -406,7 +406,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -502,7 +502,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -529,7 +529,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -549,7 +549,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -645,7 +645,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -678,7 +678,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -698,7 +698,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -794,7 +794,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -827,7 +827,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -847,7 +847,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -943,7 +943,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -970,7 +970,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -990,8 +990,8 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1028,7 +1028,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1055,7 +1055,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1075,8 +1075,8 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1112,7 +1112,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1139,7 +1139,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1160,7 +1160,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1256,7 +1256,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1286,7 +1286,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1306,8 +1306,8 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init", init]
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["arrayinit.temp"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1344,7 +1344,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1374,7 +1374,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1395,13 +1395,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1442,7 +1442,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1471,7 +1471,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1498,13 +1498,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1545,7 +1545,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1574,7 +1574,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1601,13 +1601,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1648,7 +1648,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1683,7 +1683,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1710,13 +1710,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1757,7 +1757,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1792,7 +1792,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1819,13 +1819,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1866,7 +1866,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1895,7 +1895,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1922,13 +1922,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1969,7 +1969,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1998,7 +1998,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2025,13 +2025,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2072,7 +2072,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2101,7 +2101,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2128,13 +2128,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2175,7 +2175,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2207,7 +2207,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2234,13 +2234,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_HasOperatorsOutline x 5>, !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>, ["openacc.reduction.init"]
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2281,7 +2281,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2313,7 +2313,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/loop.cpp b/clang/test/CIR/CodeGenOpenACC/loop.cpp
index 91d688ba5c1b0..ca8a48f73b6ca 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop.cpp
@@ -2,10 +2,10 @@
extern "C" void acc_loop(int *A, int *B, int *C, int N) {
// CHECK: cir.func{{.*}} @acc_loop(%[[ARG_A:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_B:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_C:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_N:.*]]: !s32i {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ALLOCA_A:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["A", init]
- // CHECK-NEXT: %[[ALLOCA_B:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["B", init]
- // CHECK-NEXT: %[[ALLOCA_C:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["C", init]
- // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["N", init]
+ // CHECK-NEXT: %[[ALLOCA_A:.*]] = cir.alloca "A" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ALLOCA_B:.*]] = cir.alloca "B" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ALLOCA_C:.*]] = cir.alloca "C" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca "N" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_A]], %[[ALLOCA_A]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG_B]], %[[ALLOCA_B]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG_C]], %[[ALLOCA_C]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/parallel.c b/clang/test/CIR/CodeGenOpenACC/parallel.c
index 152828e4f6df4..f00bd89ff358e 100644
--- a/clang/test/CIR/CodeGenOpenACC/parallel.c
+++ b/clang/test/CIR/CodeGenOpenACC/parallel.c
@@ -2,7 +2,7 @@
void acc_parallel(int cond) {
// CHECK: cir.func{{.*}} @acc_parallel(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc parallel
{}
@@ -446,8 +446,8 @@ void acc_parallel(int cond) {
void acc_parallel_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_parallel_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg1", init]
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg2", init]
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp
index 396674a934990..5b884a01a538f 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp
@@ -13,7 +13,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_8CtorDtor : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CtorDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!rec_CtorDtor x 5>, !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// Init Section.
// CHECK-NEXT: cir.scope {
@@ -21,7 +21,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -49,7 +49,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -79,11 +79,11 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_8CtorDtor : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CtorDtor x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!rec_CtorDtor x 5>, !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, ["openacc.private.init", init] {alignment = 16 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -103,7 +103,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -125,14 +125,14 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!rec_CtorDtor x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!rec_CtorDtor x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>
// Init Section:
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB2:.*]] = acc.get_lowerbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -149,7 +149,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -185,7 +185,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -204,7 +204,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -244,12 +244,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!rec_CtorDtor x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>, ["openacc.private.init", init] {alignment = 16 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!rec_CtorDtor x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> -> !cir.ptr<!cir.array<!rec_CtorDtor x 25>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<25> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 25>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -270,7 +270,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<25> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 25>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -292,7 +292,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B][B])
// CHECK-NEXT:acc.private.recipe @privatization__Bcnt3__ZTSA5_A5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -300,7 +300,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -315,7 +315,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -330,7 +330,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -373,7 +373,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB3_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -390,7 +390,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -407,7 +407,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -456,14 +456,14 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
// Init Section:
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB2:.*]] = acc.get_lowerbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -480,7 +480,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -494,7 +494,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[ARR_DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[ARR_DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -532,7 +532,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -551,7 +551,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -567,7 +567,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[ARR_DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -607,12 +607,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>, ["openacc.private.init", init] {alignment = 16 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> -> !cir.ptr<!cir.array<!rec_CtorDtor x 125>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<125> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 125>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -633,7 +633,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<125> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 125>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp
index 4a167fa7ef207..c721467bf5338 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp
@@ -8,7 +8,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_5NoOps : !cir.ptr<!cir.array<!rec_NoOps x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_NoOps x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoOps x 5>, !cir.ptr<!cir.array<!rec_NoOps x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// Init Section.
// CHECK-NEXT: cir.scope {
@@ -16,7 +16,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -44,11 +44,11 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_5NoOps : !cir.ptr<!cir.array<!rec_NoOps x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_NoOps x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoOps x 5>, !cir.ptr<!cir.array<!rec_NoOps x 5>>, ["openacc.private.init", init] {alignment = 16 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -70,7 +70,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!rec_NoOps x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!rec_NoOps x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -78,7 +78,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -95,7 +95,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -133,12 +133,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!rec_NoOps x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>, ["openacc.private.init", init] {alignment = 16 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!rec_NoOps x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> -> !cir.ptr<!cir.array<!rec_NoOps x 25>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<25> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_NoOps x 25>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -160,7 +160,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B][B])
// CHECK-NEXT:acc.private.recipe @privatization__Bcnt3__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -168,7 +168,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -183,7 +183,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -198,7 +198,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -245,14 +245,14 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
// Init Section:
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB2:.*]] = acc.get_lowerbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -269,7 +269,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -283,7 +283,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[ARR_DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[ARR_DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -323,12 +323,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>, ["openacc.private.init", init] {alignment = 16 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> -> !cir.ptr<!cir.array<!rec_NoOps x 125>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<125> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_NoOps x 125>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp
index 74cb567076f21..5bd94c130b43f 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp
@@ -6,7 +6,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -15,7 +15,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -24,7 +24,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr[A:B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_i : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!s32i x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!s32i x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -35,7 +35,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_i : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.array<!s32i x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.array<!s32i x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -44,7 +44,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B][B])
// CHECK-NEXT:acc.private.recipe @privatization__Bcnt3__ZTSA5_A5_A5_i : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -57,7 +57,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_A5_i : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -68,7 +68,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_A5_i : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp
index 63434be716998..bd904b20a836e 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp
@@ -13,16 +13,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB1_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -51,7 +51,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -79,7 +79,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -110,7 +110,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK: acc.private.recipe @privatization__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -119,16 +119,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -156,10 +156,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -187,7 +187,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -202,7 +202,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -237,7 +237,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -254,7 +254,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -293,7 +293,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -302,16 +302,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -339,10 +339,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -369,10 +369,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -401,7 +401,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -416,7 +416,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -431,7 +431,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -474,7 +474,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -492,7 +492,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -509,7 +509,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -558,16 +558,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -595,10 +595,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -629,7 +629,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -639,7 +639,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr[B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_P8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_CtorDtor> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -653,10 +653,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -685,7 +685,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -700,7 +700,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -736,7 +736,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -753,7 +753,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -792,7 +792,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_P8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.ptr<!rec_CtorDtor> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -802,16 +802,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_CtorDtor x 5>, !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -840,7 +840,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -855,7 +855,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -890,7 +890,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -907,7 +907,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -946,7 +946,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -955,7 +955,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSA5_PP8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
@@ -969,10 +969,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -999,10 +999,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1030,7 +1030,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1045,7 +1045,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1060,7 +1060,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1103,7 +1103,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -1121,7 +1121,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1138,7 +1138,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1187,7 +1187,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_PP8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -1201,10 +1201,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1235,7 +1235,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_PP8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -1244,16 +1244,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1281,10 +1281,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.array<!rec_CtorDtor x 5>, !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1312,7 +1312,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1327,7 +1327,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1342,7 +1342,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1385,7 +1385,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -1403,7 +1403,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1420,7 +1420,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1469,16 +1469,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1505,10 +1505,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.array<!rec_CtorDtor x 5>, !cir.ptr<!cir.array<!rec_CtorDtor x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1536,7 +1536,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1551,7 +1551,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1564,7 +1564,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -1602,7 +1602,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1621,7 +1621,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1637,7 +1637,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[ELT]], %[[IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -1677,7 +1677,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -1688,16 +1688,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_CtorDtor> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1733,10 +1733,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1763,7 +1763,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1778,7 +1778,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1836,7 +1836,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -1854,7 +1854,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1871,7 +1871,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1920,16 +1920,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_CtorDtor> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1961,7 +1961,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp
index d3b4205460225..f1bff4cb1f02e 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp
@@ -8,16 +8,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB1_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -46,7 +46,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -74,7 +74,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK: acc.private.recipe @privatization__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -83,16 +83,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -120,10 +120,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -150,7 +150,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -165,7 +165,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -202,7 +202,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -211,16 +211,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -248,10 +248,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -278,10 +278,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -309,7 +309,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -324,7 +324,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -339,7 +339,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -386,16 +386,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -423,10 +423,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -457,7 +457,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -467,7 +467,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr[B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_P5NoOps : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_NoOps> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -481,10 +481,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -512,7 +512,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -527,7 +527,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -565,7 +565,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_P5NoOps : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.ptr<!rec_NoOps> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -576,16 +576,16 @@ void do_things(unsigned A, unsigned B) {
;
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_NoOps x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!rec_NoOps x 5>, !cir.ptr<!cir.array<!rec_NoOps x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -613,7 +613,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -628,7 +628,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -664,7 +664,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.array<!rec_NoOps x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -673,7 +673,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSA5_PP5NoOps : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
@@ -687,10 +687,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -717,10 +717,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -747,7 +747,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -762,7 +762,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -777,7 +777,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -824,7 +824,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_PP5NoOps : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -838,10 +838,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -872,7 +872,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_PP5NoOps : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -881,16 +881,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_NoOps x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -918,10 +918,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.array<!rec_NoOps x 5>, !cir.ptr<!cir.array<!rec_NoOps x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -948,7 +948,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -963,7 +963,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -978,7 +978,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1025,16 +1025,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!rec_NoOps x 5>>, !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1062,10 +1062,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.array<!rec_NoOps x 5>, !cir.ptr<!cir.array<!rec_NoOps x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1092,7 +1092,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1107,7 +1107,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1120,7 +1120,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["__array_idx"] {alignment = 1 : i64}
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -1160,7 +1160,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -1171,16 +1171,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_NoOps> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1216,10 +1216,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1246,7 +1246,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1261,7 +1261,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1276,7 +1276,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1323,16 +1323,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_NoOps> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1364,7 +1364,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp
index 111428aaa9bb6..c9ba81735fb71 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp
@@ -6,16 +6,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!s32i>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB1_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -46,7 +46,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!s32i>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -55,16 +55,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -92,10 +92,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -126,7 +126,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -135,16 +135,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -172,10 +172,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -201,10 +201,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -237,16 +237,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -274,10 +274,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -308,7 +308,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -318,7 +318,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr[B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_Pi : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!s32i> x 5>, !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
//
@@ -331,10 +331,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -365,7 +365,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_Pi : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.ptr<!s32i> x 5>, !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -375,16 +375,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_i : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -416,7 +416,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_i : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -425,7 +425,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSA5_PPi : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
@@ -439,10 +439,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -469,10 +469,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -505,7 +505,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_PPi : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -519,10 +519,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -553,7 +553,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_PPi : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>, !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>, ["openacc.private.init"] {alignment = 16 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -562,16 +562,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPA5_i : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -600,10 +600,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -636,16 +636,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPA5_i : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -673,10 +673,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -707,7 +707,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPA5_i : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -718,16 +718,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPA5_Pi : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!s32i> x 5>, !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -763,10 +763,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -800,16 +800,16 @@ void do_things(unsigned A, unsigned B) {
// #pragma acc parallel private(PtrArrayPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_Pi : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!s32i> x 5>, !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -841,7 +841,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr)
// CHECK: acc.private.recipe @privatization__ZTSPA5_Pi : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>, ["openacc.private.init"]
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp
index a5b5ae605e36b..dfb5bbbfda808 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp
@@ -14,7 +14,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK: acc.private.recipe @privatization__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -22,17 +22,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -63,16 +63,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUNDS1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -102,11 +102,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -141,16 +141,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUNDS1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUNDS3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -180,12 +180,12 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -214,11 +214,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -247,7 +247,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUNDS3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -263,7 +263,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -278,7 +278,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -322,7 +322,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUNDS3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -340,7 +340,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -357,7 +357,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -407,7 +407,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK: acc.private.recipe @privatization__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -415,17 +415,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -455,16 +455,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}, %[[BOUNDS1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -494,11 +494,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -528,7 +528,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -545,7 +545,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -581,7 +581,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -600,7 +600,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -642,7 +642,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -650,17 +650,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_CTORDTOR:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_CTORDTOR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !rec_CtorDtor, !cir.ptr<!rec_CtorDtor>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -691,7 +691,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -719,7 +719,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp
index a669adc312caa..56454e5fb0ce3 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp
@@ -9,24 +9,24 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK: acc.private.recipe @privatization__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
#pragma acc parallel private(ThreePtr[A])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -56,16 +56,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -96,11 +96,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -133,16 +133,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -173,11 +173,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -207,11 +207,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -241,7 +241,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -257,7 +257,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -272,7 +272,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -322,7 +322,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK: acc.private.recipe @privatization__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -330,17 +330,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -370,16 +370,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -409,11 +409,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -443,7 +443,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -460,7 +460,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -500,7 +500,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -508,17 +508,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_NOOPS:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_NOOPS]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -549,7 +549,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp
index e75f2beae437d..4e5265ba38b41 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp
@@ -7,24 +7,24 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK: acc.private.recipe @privatization__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
#pragma acc parallel private(ThreePtr[A])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -54,17 +54,17 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -94,10 +94,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -131,16 +131,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -171,11 +171,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -204,10 +204,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -245,7 +245,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -253,17 +253,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -294,16 +294,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -333,11 +333,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -373,7 +373,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!s32i>> {{.*}}):
-// CHECK-NEXT: cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["openacc.private.init"] {alignment = 8 : i64}
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -381,17 +381,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!s32i>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["openacc.private.init"]
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
diff --git a/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp b/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp
index fa92b6c0c230a..667ec4bc3d00a 100644
--- a/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp
@@ -13,7 +13,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel reduction(+:ThreeArr[B][B][B])
// CHECK:acc.reduction.recipe @reduction_add__Bcnt3__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>, !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>, ["openacc.reduction.init"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -21,7 +21,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -36,7 +36,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -51,7 +51,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -96,7 +96,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -113,7 +113,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -130,7 +130,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -180,7 +180,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB3_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -197,7 +197,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -214,7 +214,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -259,16 +259,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel reduction(*:ThreePtr[B][B][A:B])
// CHECK: acc.reduction.recipe @reduction_mul__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>, ["openacc.reduction.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -298,12 +298,12 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
//
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -332,11 +332,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[CALC_ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -365,7 +365,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -381,7 +381,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -396,7 +396,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -442,7 +442,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -460,7 +460,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -477,7 +477,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -527,7 +527,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -545,7 +545,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -562,7 +562,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -609,16 +609,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel reduction(||:PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt3__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>, ["openacc.reduction.init"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca !cir.array<!cir.ptr<!rec_NoOps> x 5>, !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -654,10 +654,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca !rec_NoOps, !cir.ptr<!rec_NoOps>, %[[ALLOCA_SIZE]] : !u64i, ["openacc.init.bounds"] {alignment = 4 : i64}
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["itr"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -684,7 +684,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -699,7 +699,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -714,7 +714,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -759,7 +759,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -776,7 +776,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -793,7 +793,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -851,7 +851,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -869,7 +869,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -886,7 +886,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64}
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/serial.c b/clang/test/CIR/CodeGenOpenACC/serial.c
index 4eccc8eb5ed1d..9bb4a84bb47eb 100644
--- a/clang/test/CIR/CodeGenOpenACC/serial.c
+++ b/clang/test/CIR/CodeGenOpenACC/serial.c
@@ -2,7 +2,7 @@
void acc_serial(int cond) {
// CHECK: cir.func{{.*}} @acc_serial(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc serial
{}
@@ -269,8 +269,8 @@ void acc_serial(int cond) {
void acc_serial_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_serial_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg1", init]
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg2", init]
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/set.c b/clang/test/CIR/CodeGenOpenACC/set.c
index 173f7493aca58..baf7f268f14a3 100644
--- a/clang/test/CIR/CodeGenOpenACC/set.c
+++ b/clang/test/CIR/CodeGenOpenACC/set.c
@@ -2,7 +2,7 @@
void acc_set(int cond) {
// CHECK: cir.func{{.*}} @acc_set(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc set device_type(*)
diff --git a/clang/test/CIR/CodeGenOpenACC/shutdown.c b/clang/test/CIR/CodeGenOpenACC/shutdown.c
index 2d738d9e7684e..22329bfafe6eb 100644
--- a/clang/test/CIR/CodeGenOpenACC/shutdown.c
+++ b/clang/test/CIR/CodeGenOpenACC/shutdown.c
@@ -2,7 +2,7 @@
void acc_shutdown(int cond) {
// CHECK: cir.func{{.*}} @acc_shutdown(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc shutdown
// CHECK-NEXT: acc.shutdown loc(#{{[a-zA-Z0-9]+}}){{$}}
diff --git a/clang/test/CIR/CodeGenOpenACC/update.c b/clang/test/CIR/CodeGenOpenACC/update.c
index 9a90620d454ee..8d7e1892e4e75 100644
--- a/clang/test/CIR/CodeGenOpenACC/update.c
+++ b/clang/test/CIR/CodeGenOpenACC/update.c
@@ -2,8 +2,8 @@
void acc_update(int parmVar, int *ptrParmVar) {
// CHECK: cir.func{{.*}} @acc_update(%[[ARG:.*]]: !s32i{{.*}}, %[[PTRARG:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["parmVar", init]
- // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["ptrParmVar", init]
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[PTRARG]], %[[PTRPARM]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/wait.c b/clang/test/CIR/CodeGenOpenACC/wait.c
index 2f4524f43fce2..435c17899b958 100644
--- a/clang/test/CIR/CodeGenOpenACC/wait.c
+++ b/clang/test/CIR/CodeGenOpenACC/wait.c
@@ -2,7 +2,7 @@
void acc_wait(int cond) {
// CHECK: cir.func{{.*}} @acc_wait(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["cond", init]
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc wait
diff --git a/clang/test/CIR/CodeGenOpenCL/as_type.cl b/clang/test/CIR/CodeGenOpenCL/as_type.cl
index fc5c3bd5a04b6..7fbda3da9622f 100644
--- a/clang/test/CIR/CodeGenOpenCL/as_type.cl
+++ b/clang/test/CIR/CodeGenOpenCL/as_type.cl
@@ -15,8 +15,8 @@ char4 f4(int x) {
}
// CIR: cir.func {{.*}} @f4
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.vector<4 x !s8i>, !cir.ptr<!cir.vector<4 x !s8i>>, ["__retval"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s8i> -> !cir.ptr<!cir.vector<4 x !s8i>>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[X_V4_I8:.*]] = cir.cast bitcast %[[TMP_X]] : !s32i -> !cir.vector<4 x !s8i>
@@ -33,8 +33,8 @@ int f6(char4 x) {
}
// CIR: cir.func {{.*}} @f6
-// CIR: %[[X_ADDR:.*]] = cir.alloca !cir.vector<4 x !s8i>, !cir.ptr<!cir.vector<4 x !s8i>>, ["x", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !cir.vector<4 x !s8i> -> !cir.ptr<!cir.vector<4 x !s8i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !cir.vector<4 x !s8i>, !cir.ptr<!cir.vector<4 x !s8i>>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!cir.vector<4 x !s8i>>, !cir.vector<4 x !s8i>
// CIR: %[[X_S32I:.*]] = cir.cast bitcast %[[TMP_X]] : !cir.vector<4 x !s8i> -> !s32i
@@ -51,8 +51,8 @@ int* int_to_ptr(int x) {
}
// CIR: cir.func {{.*}} @int_to_ptr
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["__retval"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[X_PTR:.*]] = cir.cast int_to_ptr %[[TMP_X]] : !s32i -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c b/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c
index fd89ceb618257..04ccb4396344a 100644
--- a/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c
+++ b/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c
@@ -6,11 +6,11 @@
// RUN: FileCheck --input-file=%t.ll %s --check-prefix=OGCG
// CIR-LABEL: cir.func no_inline no_proto dso_local @main() -> !s32i {{.*}}{
-// CIR: [[RETVAL:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
-// CIR: [[J:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["j"] {alignment = 4 : i64}
+// CIR: [[RETVAL:%.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR: [[J:%.*]] = cir.alloca "j" align(4) !s32i -> !cir.ptr<!s32i>
// CIR: omp.parallel {
// CIR: cir.scope {
-// CIR: [[I:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+// CIR: [[I:%.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CIR: [[ZERO1:%.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store align(4) [[ZERO1]], [[I]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.for : cond {
diff --git a/clang/test/CIR/CodeGenOpenMP/parallel.c b/clang/test/CIR/CodeGenOpenMP/parallel.c
index d04784879540a..d36a9e30fa447 100644
--- a/clang/test/CIR/CodeGenOpenMP/parallel.c
+++ b/clang/test/CIR/CodeGenOpenMP/parallel.c
@@ -34,8 +34,8 @@ void emit_simple_parallel() {
void parallel_with_operations() {
// CHECK: cir.func{{.*}}@parallel_with_operations
int a, b;
- // CHECK-NEXT: cir.alloca{{.*}}["a"]
- // CHECK-NEXT: cir.alloca{{.*}}["b"]
+ // CHECK-NEXT: cir.alloca "a" {{.*}}
+ // CHECK-NEXT: cir.alloca "b" {{.*}}
// TODO(OMP): At the moment this results in 3 NYI diagnostics, 1 each for the
// clauses + 1 for the CapturedStmt. When those are implemented, the check
// lines will need updating.
diff --git a/clang/test/CIR/IR/alloca.cir b/clang/test/CIR/IR/alloca.cir
index f8259c656eb37..effeabb380cca 100644
--- a/clang/test/CIR/IR/alloca.cir
+++ b/clang/test/CIR/IR/alloca.cir
@@ -7,12 +7,12 @@
!void = !cir.void
module {
cir.func dso_local @_Z11test_allocam(%arg0: !u64i) -> !cir.ptr<!void> {
- %0 = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init] {alignment = 8 : i64}
- %1 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"] {alignment = 8 : i64}
+ %0 = cir.alloca "n" align(8) init !u64i -> !cir.ptr<!u64i>
+ %1 = cir.alloca "__retval" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
cir.store %arg0, %0 : !u64i, !cir.ptr<!u64i>
%2 = cir.load align(8) %0 : !cir.ptr<!u64i>, !u64i
// Dynamically sized alloca
- %3 = cir.alloca !u8i, !cir.ptr<!u8i>, %2 : !u64i, ["bi_alloca"] {alignment = 16 : i64}
+ %3 = cir.alloca "bi_alloca" align(16) %2 : !u64i, !u8i -> !cir.ptr<!u8i>
%4 = cir.cast bitcast %3 : !cir.ptr<!u8i> -> !cir.ptr<!void>
cir.store %4, %1 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
%5 = cir.load %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
@@ -20,11 +20,11 @@ module {
}
// CHECK: cir.func dso_local @_Z11test_allocam(%arg0: !u64i) -> !cir.ptr<!void> {
- // CHECK: %0 = cir.alloca !u64i, !cir.ptr<!u64i>, ["n", init] {alignment = 8 : i64}
- // CHECK: %1 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["__retval"] {alignment = 8 : i64}
+ // CHECK: %0 = cir.alloca "n" align(8) init !u64i -> !cir.ptr<!u64i>
+ // CHECK: %1 = cir.alloca "__retval" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
// CHECK: cir.store %arg0, %0 : !u64i, !cir.ptr<!u64i>
// CHECK: %2 = cir.load align(8) %0 : !cir.ptr<!u64i>, !u64i
- // CHECK: %3 = cir.alloca !u8i, !cir.ptr<!u8i>, %2 : !u64i, ["bi_alloca"] {alignment = 16 : i64}
+ // CHECK: %3 = cir.alloca "bi_alloca" align(16) %2 : !u64i, !u8i -> !cir.ptr<!u8i>
// CHECK: %4 = cir.cast bitcast %3 : !cir.ptr<!u8i> -> !cir.ptr<!void>
// CHECK: cir.store %4, %1 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CHECK: %5 = cir.load %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
@@ -33,39 +33,39 @@ module {
// Parse tests for all flag combinations
cir.func dso_local @test_alloca_flags() {
// No flags
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
// init only
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
+ %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
// const only
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", const] {alignment = 4 : i64}
+ %2 = cir.alloca "c" align(4) const !s32i -> !cir.ptr<!s32i>
// init + const
- %3 = cir.alloca !s32i, !cir.ptr<!s32i>, ["d", init, const] {alignment = 4 : i64}
+ %3 = cir.alloca "d" align(4) init const !s32i -> !cir.ptr<!s32i>
// cleanup_dest_slot only
- %4 = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", cleanup_dest_slot] {alignment = 4 : i64}
+ %4 = cir.alloca "e" align(4) cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
// all flags
- %6 = cir.alloca !s32i, !cir.ptr<!s32i>, ["f", init, const, cleanup_dest_slot] {alignment = 4 : i64}
+ %6 = cir.alloca "f" align(4) init const cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
// dynamic size, no flags
%sz = cir.const #cir.int<4> : !u64i
- %7 = cir.alloca !u8i, !cir.ptr<!u8i>, %sz : !u64i, ["h"] {alignment = 16 : i64}
+ %7 = cir.alloca "h" align(16) %sz : !u64i, !u8i -> !cir.ptr<!u8i>
// dynamic size + init
- %8 = cir.alloca !u8i, !cir.ptr<!u8i>, %sz : !u64i, ["i", init] {alignment = 16 : i64}
+ %8 = cir.alloca "i" align(16) init %sz : !u64i, !u8i -> !cir.ptr<!u8i>
cir.return
}
// CHECK-LABEL: cir.func dso_local @test_alloca_flags
- // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
- // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
- // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["c", const] {alignment = 4 : i64}
- // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["d", init, const] {alignment = 4 : i64}
- // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["e", cleanup_dest_slot] {alignment = 4 : i64}
- // CHECK: cir.alloca !s32i, !cir.ptr<!s32i>, ["f", init, const, cleanup_dest_slot] {alignment = 4 : i64}
- // CHECK: cir.alloca !u8i, !cir.ptr<!u8i>, %{{.*}} : !u64i, ["h"] {alignment = 16 : i64}
- // CHECK: cir.alloca !u8i, !cir.ptr<!u8i>, %{{.*}} : !u64i, ["i", init] {alignment = 16 : i64}
+ // CHECK: cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
+ // CHECK: cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CHECK: cir.alloca "c" align(4) const !s32i -> !cir.ptr<!s32i>
+ // CHECK: cir.alloca "d" align(4) init const !s32i -> !cir.ptr<!s32i>
+ // CHECK: cir.alloca "e" align(4) cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+ // CHECK: cir.alloca "f" align(4) init const cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+ // CHECK: cir.alloca "h" align(16) %{{.*}} : !u64i, !u8i -> !cir.ptr<!u8i>
+ // CHECK: cir.alloca "i" align(16) init %{{.*}} : !u64i, !u8i -> !cir.ptr<!u8i>
}
diff --git a/clang/test/CIR/IR/array-ctor.cir b/clang/test/CIR/IR/array-ctor.cir
index 239d7b9187603..9d6573ed9503c 100644
--- a/clang/test/CIR/IR/array-ctor.cir
+++ b/clang/test/CIR/IR/array-ctor.cir
@@ -8,7 +8,7 @@
module {
cir.func private @_ZN1SC1Ev(!cir.ptr<!rec_S>)
cir.func dso_local @_Z3foov() {
- %0 = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s", init] {alignment = 16 : i64}
+ %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
cir.array.ctor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
^bb0(%arg0: !cir.ptr<!rec_S>):
cir.call @_ZN1SC1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
@@ -18,7 +18,7 @@ module {
// CHECK: cir.func private @_ZN1SC1Ev(!cir.ptr<!rec_S>)
// CHECK: cir.func dso_local @_Z3foov() {
- // CHECK: %0 = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s", init] {alignment = 16 : i64}
+ // CHECK: %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
// CHECK: cir.array.ctor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
// CHECK: ^bb0(%arg0: !cir.ptr<!rec_S>):
// CHECK: cir.call @_ZN1SC1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
diff --git a/clang/test/CIR/IR/array-dtor.cir b/clang/test/CIR/IR/array-dtor.cir
index 25c961b4c6211..9a7328ec625a8 100644
--- a/clang/test/CIR/IR/array-dtor.cir
+++ b/clang/test/CIR/IR/array-dtor.cir
@@ -6,7 +6,7 @@
module {
cir.func private @_ZN1SD1Ev(!cir.ptr<!rec_S>)
cir.func dso_local @_Z3foov() {
- %0 = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s", init] {alignment = 16 : i64}
+ %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
cir.array.dtor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
^bb0(%arg0: !cir.ptr<!rec_S>):
cir.call @_ZN1SD1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
@@ -16,7 +16,7 @@ module {
// CHECK: cir.func private @_ZN1SD1Ev(!cir.ptr<!rec_S>)
// CHECK: cir.func dso_local @_Z3foov() {
- // CHECK: %0 = cir.alloca !cir.array<!rec_S x 42>, !cir.ptr<!cir.array<!rec_S x 42>>, ["s", init] {alignment = 16 : i64}
+ // CHECK: %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
// CHECK: cir.array.dtor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
// CHECK: ^bb0(%arg0: !cir.ptr<!rec_S>):
// CHECK: cir.call @_ZN1SD1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
diff --git a/clang/test/CIR/IR/array.cir b/clang/test/CIR/IR/array.cir
index ddc6b92b11ee9..ca962b21ffe5d 100644
--- a/clang/test/CIR/IR/array.cir
+++ b/clang/test/CIR/IR/array.cir
@@ -29,35 +29,35 @@ cir.global external @e = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s
// CHECK: cir.global external @e = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i], trailing_zeros> : !cir.array<!s32i x 10>
cir.func @func() {
- %0 = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["l"] {alignment = 4 : i64}
+ %0 = cir.alloca "l" align(4) !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
cir.return
}
// CHECK: cir.func{{.*}} @func() {
-// CHECK: %0 = cir.alloca !cir.array<!s32i x 10>, !cir.ptr<!cir.array<!s32i x 10>>, ["l"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "l" align(4) !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
// CHECK: cir.return
// CHECK: }
cir.func @func2(%arg0: !cir.ptr<!s32i>) {
- %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p", init] {alignment = 8 : i64}
+ %0 = cir.alloca "p" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
cir.return
}
// CHECK: cir.func{{.*}} @func2(%arg0: !cir.ptr<!s32i>) {
-// CHECK: %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["p", init] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "p" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
// CHECK: cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK: cir.return
// CHECK: }
cir.func @func3(%arg0: !cir.ptr<!cir.array<!s32i x 10>>) {
- %0 = cir.alloca !cir.ptr<!cir.array<!s32i x 10>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>, ["pp", init] {alignment = 8 : i64}
+ %0 = cir.alloca "pp" align(8) init !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
cir.store %arg0, %0 : !cir.ptr<!cir.array<!s32i x 10>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
cir.return
}
// CHECK: cir.func{{.*}} @func3(%arg0: !cir.ptr<!cir.array<!s32i x 10>>) {
-// CHECK: %0 = cir.alloca !cir.ptr<!cir.array<!s32i x 10>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>, ["pp", init] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "pp" align(8) init !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
// CHECK: cir.store %arg0, %0 : !cir.ptr<!cir.array<!s32i x 10>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
// CHECK: cir.return
// CHECK: }
diff --git a/clang/test/CIR/IR/binassign.cir b/clang/test/CIR/IR/binassign.cir
index 02471264d779e..e00f42c6e0d3f 100644
--- a/clang/test/CIR/IR/binassign.cir
+++ b/clang/test/CIR/IR/binassign.cir
@@ -5,10 +5,10 @@
#true = #cir.bool<true> : !cir.bool
module {
cir.func @binary_assign() {
- %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b"] {alignment = 1 : i64}
- %1 = cir.alloca !s8i, !cir.ptr<!s8i>, ["c"] {alignment = 1 : i64}
- %2 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f"] {alignment = 4 : i64}
- %3 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"] {alignment = 4 : i64}
+ %0 = cir.alloca "b" align(1) !cir.bool -> !cir.ptr<!cir.bool>
+ %1 = cir.alloca "c" align(1) !s8i -> !cir.ptr<!s8i>
+ %2 = cir.alloca "f" align(4) !cir.float -> !cir.ptr<!cir.float>
+ %3 = cir.alloca "i" align(4) !s32i -> !cir.ptr<!s32i>
%4 = cir.const #true
cir.store %4, %0 : !cir.bool, !cir.ptr<!cir.bool>
%5 = cir.const #cir.int<65> : !s32i
@@ -27,10 +27,10 @@ module {
// CHECK: #true = #cir.bool<true> : !cir.bool
// CHECK: module {
// CHECK: cir.func{{.*}} @binary_assign() {
-// CHECK: %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b"] {alignment = 1 : i64}
-// CHECK: %1 = cir.alloca !s8i, !cir.ptr<!s8i>, ["c"] {alignment = 1 : i64}
-// CHECK: %2 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["f"] {alignment = 4 : i64}
-// CHECK: %3 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "b" align(1) !cir.bool -> !cir.ptr<!cir.bool>
+// CHECK: %1 = cir.alloca "c" align(1) !s8i -> !cir.ptr<!s8i>
+// CHECK: %2 = cir.alloca "f" align(4) !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %3 = cir.alloca "i" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: %4 = cir.const #true
// CHECK: cir.store %4, %0 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK: %5 = cir.const #cir.int<65> : !s32i
diff --git a/clang/test/CIR/IR/bitfield_info.cir b/clang/test/CIR/IR/bitfield_info.cir
index 7afb8fdd3b450..1e122d2cf909a 100644
--- a/clang/test/CIR/IR/bitfield_info.cir
+++ b/clang/test/CIR/IR/bitfield_info.cir
@@ -11,7 +11,7 @@
// Use bitfield to enforce printing the attribute
cir.func dso_local @init(%arg0: !cir.ptr<!rec_S> ){
- %0 = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["s", init] {alignment = 8 : i64}
+ %0 = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
cir.store %arg0, %0 : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
%1 = cir.load align(8) %0 : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
%2 = cir.get_member %1[0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u32i>
diff --git a/clang/test/CIR/IR/cmp.cir b/clang/test/CIR/IR/cmp.cir
index 9c70545fb1b84..476b4647c19f1 100644
--- a/clang/test/CIR/IR/cmp.cir
+++ b/clang/test/CIR/IR/cmp.cir
@@ -4,9 +4,9 @@
module {
cir.func @c0(%arg0: !s32i, %arg1: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
- %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
%3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -37,9 +37,9 @@ module {
}
// CHECK: cir.func{{.*}} @c0(%arg0: !s32i, %arg1: !s32i) {
- // CHECK-NEXT: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
- // CHECK-NEXT: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
- // CHECK-NEXT: %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ // CHECK-NEXT: %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -70,9 +70,9 @@ module {
// CHECK-NEXT: }
cir.func @c0_unsigned(%arg0: !u32i, %arg1: !u32i) {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init] {alignment = 4 : i64}
- %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+ %1 = cir.alloca "b" align(4) init !u32i -> !cir.ptr<!u32i>
+ %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
cir.store %arg1, %1 : !u32i, !cir.ptr<!u32i>
%3 = cir.load %0 : !cir.ptr<!u32i>, !u32i
@@ -103,9 +103,9 @@ module {
}
// CHECK: cir.func{{.*}} @c0_unsigned(%arg0: !u32i, %arg1: !u32i) {
- // CHECK-NEXT: %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
- // CHECK-NEXT: %1 = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init] {alignment = 4 : i64}
- // CHECK-NEXT: %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ // CHECK-NEXT: %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(4) init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %arg1, %1 : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!u32i>, !u32i
@@ -136,9 +136,9 @@ module {
// CHECK-NEXT: }
cir.func @c0_float(%arg0: !cir.float, %arg1: !cir.float) {
- %0 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init] {alignment = 4 : i64}
- %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ %0 = cir.alloca "a" align(4) init !cir.float -> !cir.ptr<!cir.float>
+ %1 = cir.alloca "b" align(4) init !cir.float -> !cir.ptr<!cir.float>
+ %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !cir.float, !cir.ptr<!cir.float>
cir.store %arg1, %1 : !cir.float, !cir.ptr<!cir.float>
%3 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
@@ -169,9 +169,9 @@ module {
}
// CHECK: cir.func{{.*}} @c0_float(%arg0: !cir.float, %arg1: !cir.float) {
- // CHECK-NEXT: %0 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a", init] {alignment = 4 : i64}
- // CHECK-NEXT: %1 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init] {alignment = 4 : i64}
- // CHECK-NEXT: %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ // CHECK-NEXT: %0 = cir.alloca "a" align(4) init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(4) init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %arg1, %1 : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
@@ -202,9 +202,9 @@ module {
// CHECK-NEXT: }
cir.func @pointer_cmp(%arg0: !cir.ptr<!s32i>, %arg1: !cir.ptr<!s32i>) {
- %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["a", init] {alignment = 8 : i64}
- %1 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["b", init] {alignment = 8 : i64}
- %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ %0 = cir.alloca "a" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ %1 = cir.alloca "b" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
cir.store %arg1, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
%3 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -235,9 +235,9 @@ module {
}
// CHECK: cir.func{{.*}} @pointer_cmp(%arg0: !cir.ptr<!s32i>, %arg1: !cir.ptr<!s32i>) {
- // CHECK-NEXT: %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["a", init] {alignment = 8 : i64}
- // CHECK-NEXT: %1 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["b", init] {alignment = 8 : i64}
- // CHECK-NEXT: %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ // CHECK-NEXT: %0 = cir.alloca "a" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %arg1, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -268,9 +268,9 @@ module {
// CHECK-NEXT: }
cir.func @bool_cmp(%arg0: !cir.bool, %arg1: !cir.bool) {
- %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init] {alignment = 1 : i64}
- %1 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init] {alignment = 1 : i64}
- %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ %0 = cir.alloca "a" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %1 = cir.alloca "b" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
cir.store %arg1, %1 : !cir.bool, !cir.ptr<!cir.bool>
%3 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
@@ -313,9 +313,9 @@ module {
}
// CHECK: cir.func{{.*}} @bool_cmp(%arg0: !cir.bool, %arg1: !cir.bool) {
- // CHECK-NEXT: %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init] {alignment = 1 : i64}
- // CHECK-NEXT: %1 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init] {alignment = 1 : i64}
- // CHECK-NEXT: %2 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] {alignment = 1 : i64}
+ // CHECK-NEXT: %0 = cir.alloca "a" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg1, %1 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
diff --git a/clang/test/CIR/IR/construct-catch-param.cir b/clang/test/CIR/IR/construct-catch-param.cir
index 8c221bfc5d338..464411831fd8a 100644
--- a/clang/test/CIR/IR/construct-catch-param.cir
+++ b/clang/test/CIR/IR/construct-catch-param.cir
@@ -29,7 +29,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E(
// enclosing scope) followed by `cir.begin_catch`.
cir.func @construct_catch_param_basic() {
cir.scope {
- %param = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %param = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -51,7 +51,7 @@ cir.func @construct_catch_param_basic() {
}
// CHECK-LABEL: cir.func @construct_catch_param_basic()
-// CHECK: %[[E:.*]] = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"]
+// CHECK: %[[E:.*]] = cir.alloca "e" {{.*}} !rec_E -> !cir.ptr<!rec_E>
// CHECK: cir.try {
// CHECK: cir.yield
// CHECK: } catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
diff --git a/clang/test/CIR/IR/func-attrs.cir b/clang/test/CIR/IR/func-attrs.cir
index 713a997d6ebec..8139562a520f6 100644
--- a/clang/test/CIR/IR/func-attrs.cir
+++ b/clang/test/CIR/IR/func-attrs.cir
@@ -10,42 +10,42 @@
cir.func no_inline dso_local @Func1(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline dso_local @Func1(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["ret"] {alignment = 8 : i64}
+ %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func2(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline dso_local @Func2(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["ret"] {alignment = 8 : i64}
+ %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func3(%arg0: !s32i, %arg1: !cir.float {llvm.noundef}) -> !cir.float {
// CHECK: cir.func no_inline dso_local @Func3(%arg0: !s32i, %arg1: !cir.float {llvm.noundef}) -> !cir.float {
- %ret = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["ret"] {alignment = 8 : i64}
+ %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func4(%arg0: !s32i, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline dso_local @Func4(%arg0: !s32i, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["ret"] {alignment = 8 : i64}
+ %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func5(%arg0: !s32i, %arg1: !cir.float) -> !cir.float {
// CHECK: cir.func no_inline dso_local @Func5(%arg0: !s32i, %arg1: !cir.float) -> !cir.float {
- %ret = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["ret"] {alignment = 8 : i64}
+ %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline comdat linkonce_odr @MemFunc(%arg0: !cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, %arg1: !s32i {llvm.noundef}, %arg2: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline comdat linkonce_odr @MemFunc(%arg0: !cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, %arg1: !s32i {llvm.noundef}, %arg2: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["ret"] {alignment = 8 : i64}
+ %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
@@ -64,11 +64,11 @@ cir.func @make_calls() {
cir.call @Func5(%int, %float) : (!s32i, !cir.float) -> (!cir.float)
// CHECK: cir.call @Func5(%{{.*}}, %{{.*}}) : (!s32i, !cir.float) -> !cir.float
- %struct = cir.alloca !rec_Struct, !cir.ptr<!rec_Struct>, ["s"] {alignment = 1 : i64}
+ %struct = cir.alloca "s" align(1) !rec_Struct -> !cir.ptr<!rec_Struct>
cir.call @MemFunc(%struct, %int, %float) : (!cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, !s32i {llvm.noundef, llvm.hot}, !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef})
// CHECK: cir.call @MemFunc(%{{.*}}, %{{.*}}, %{{.*}}) : (!cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, !s32i {llvm.hot, llvm.noundef}, !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef})
- %fptr = cir.alloca !cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>>, ["fp"] {alignment = 8 : i64}
+ %fptr = cir.alloca "fp" align(8) !cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>>
%fptr_load = cir.load align(8) %fptr : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>
cir.call %fptr_load(%int, %float) : (!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>, !s32i {llvm.noundef, llvm.hot}, !cir.float {llvm.noundef}) -> (!s32i {llvm.noundef})
// CHECK: cir.call %{{.*}}(%{{.*}}, %{{.*}}) : (!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>, !s32i {llvm.hot, llvm.noundef}, !cir.float {llvm.noundef}) -> (!s32i {llvm.noundef})
diff --git a/clang/test/CIR/IR/func.cir b/clang/test/CIR/IR/func.cir
index f380c6cd5725c..5708726c71b30 100644
--- a/clang/test/CIR/IR/func.cir
+++ b/clang/test/CIR/IR/func.cir
@@ -111,7 +111,7 @@ cir.func @ullfunc() -> !u64i {
cir.func coroutine @coro() {
cir.coro.body {
cir.await(init, ready : {
- %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, [""] {alignment = 1 : i64}
+ %0 = cir.alloca "" align(1) !cir.bool -> !cir.ptr<!cir.bool>
%1 = cir.load align(1) %0 : !cir.ptr<!cir.bool>, !cir.bool
cir.condition(%1)
}, suspend : {
diff --git a/clang/test/CIR/IR/indirect-br.cir b/clang/test/CIR/IR/indirect-br.cir
index 56c5ce99ef5a6..833ac370489bb 100644
--- a/clang/test/CIR/IR/indirect-br.cir
+++ b/clang/test/CIR/IR/indirect-br.cir
@@ -3,10 +3,10 @@
!void = !cir.void
cir.func @E() {
- %0 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init] {alignment = 8 : i64}
- %1 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr2", init] {alignment = 8 : i64}
- %2 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr3", init] {alignment = 8 : i64}
- %3 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr4", init] {alignment = 8 : i64}
+ %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %1 = cir.alloca "ptr2" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %2 = cir.alloca "ptr3" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %3 = cir.alloca "ptr4" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
%4 = cir.block_address <@E, "D"> : !cir.ptr<!void>
cir.store align(8) %4, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
%5 = cir.block_address <@E, "C"> : !cir.ptr<!void>
diff --git a/clang/test/CIR/IR/inline-asm.cir b/clang/test/CIR/IR/inline-asm.cir
index 907c7944670e2..bf91d2c8ea5d8 100644
--- a/clang/test/CIR/IR/inline-asm.cir
+++ b/clang/test/CIR/IR/inline-asm.cir
@@ -47,7 +47,7 @@ cir.func @f3() {
}
cir.func @f4(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: cir.asm(x86_att,
// CHECK: out = [],
@@ -76,7 +76,7 @@ cir.func @f5() {
cir.return
}
cir.func @f6() -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK: %1 = cir.asm(x86_att,
// CHECK: out = [],
// CHECK: in = [],
@@ -92,7 +92,7 @@ cir.func @f6() -> !s32i {
cir.return %3 : !s32i
}
cir.func @f7(%arg0: !u32i) -> !u32i {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
%1 = cir.load align(4) %0 : !cir.ptr<!u32i>, !u32i
// CHECK: %2 = cir.asm(x86_att,
diff --git a/clang/test/CIR/IR/invalid-complex.cir b/clang/test/CIR/IR/invalid-complex.cir
index 9ec796700f7f5..b45f4fd0908aa 100644
--- a/clang/test/CIR/IR/invalid-complex.cir
+++ b/clang/test/CIR/IR/invalid-complex.cir
@@ -26,7 +26,7 @@ cir.global external @ci2 = #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> :
module {
cir.func @complex_real_invalid_result_type() -> !cir.double {
- %0 = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"] {alignment = 8 : i64}
+ %0 = cir.alloca "c" align(8) !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
%2 = cir.load align(8) %0 : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// expected-error @below {{result type does not match operand type}}
%3 = cir.complex.real %2 : !cir.complex<!cir.double> -> !cir.float
@@ -38,7 +38,7 @@ module {
module {
cir.func @complex_imag_invalid_result_type() -> !cir.double {
- %0 = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"] {alignment = 8 : i64}
+ %0 = cir.alloca "c" align(8) !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
%2 = cir.load align(8) %0 : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// expected-error @below {{result type does not match operand type}}
%3 = cir.complex.imag %2 : !cir.complex<!cir.double> -> !cir.float
@@ -51,7 +51,7 @@ module {
module {
cir.func @complex_real_ptr_invalid_result_type() -> !cir.double {
- %0 = cir.alloca !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>, ["c"] {alignment = 8 : i64}
+ %0 = cir.alloca "c" align(8) !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
// expected-error @below {{result type does not match operand type}}
%1 = cir.complex.real_ptr %0 : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.float>
cir.return
diff --git a/clang/test/CIR/IR/invalid-construct-catch-param.cir b/clang/test/CIR/IR/invalid-construct-catch-param.cir
index 353b33a6c6bd4..09913f9dbc356 100644
--- a/clang/test/CIR/IR/invalid-construct-catch-param.cir
+++ b/clang/test/CIR/IR/invalid-construct-catch-param.cir
@@ -11,7 +11,7 @@ cir.global "private" constant external @_ZTI1E : !cir.ptr<!u8i>
cir.func @copy_fn_missing() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -45,7 +45,7 @@ cir.func private @plain_copy_fn(!cir.ptr<!rec_E>, !cir.ptr<!rec_E>)
cir.func @copy_fn_missing_thunk_attr() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -80,7 +80,7 @@ cir.func private @bad_copy_fn_arity(!cir.ptr<!rec_E>)
cir.func @copy_fn_wrong_arity() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -117,7 +117,7 @@ cir.func private @bad_copy_fn_ret(
cir.func @copy_fn_non_void_return() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -155,7 +155,7 @@ cir.func private @bad_copy_fn_first_arg(
cir.func @copy_fn_first_arg_mismatch() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -193,7 +193,7 @@ cir.func private @bad_copy_fn_second_arg(
cir.func @copy_fn_second_arg_mismatch() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -233,7 +233,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E(
// `cir.begin_catch`.
cir.func @construct_not_followed_by_begin_catch() {
cir.scope {
- %p = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
// expected-error @below {{catch handler region must start with 'cir.begin_catch'}}
cir.try {
cir.yield
diff --git a/clang/test/CIR/IR/invalid-data-member.cir b/clang/test/CIR/IR/invalid-data-member.cir
index 2ba20b8c7f378..83ef0c996918c 100644
--- a/clang/test/CIR/IR/invalid-data-member.cir
+++ b/clang/test/CIR/IR/invalid-data-member.cir
@@ -35,7 +35,7 @@
module {
cir.func @invalid_base_type(%arg0 : !cir.data_member<!u32i in !struct1>) {
- %0 = cir.alloca !struct2, !cir.ptr<!struct2>, ["tmp"] {alignment = 4 : i64}
+ %0 = cir.alloca "tmp" align(4) !struct2 -> !cir.ptr<!struct2>
// expected-error at +1 {{record type does not match the member pointer type}}
%1 = cir.get_runtime_member %0[%arg0 : !cir.data_member<!u32i in !struct1>] : !cir.ptr<!struct2> -> !cir.ptr<!u32i>
cir.return
@@ -50,7 +50,7 @@ module {
module {
cir.func @invalid_base_type(%arg0 : !cir.data_member<!u32i in !struct1>) {
- %0 = cir.alloca !struct1, !cir.ptr<!struct1>, ["tmp"] {alignment = 4 : i64}
+ %0 = cir.alloca "tmp" align(4) !struct1 -> !cir.ptr<!struct1>
// expected-error at +1 {{result type does not match the member pointer type}}
%1 = cir.get_runtime_member %0[%arg0 : !cir.data_member<!u32i in !struct1>] : !cir.ptr<!struct1> -> !cir.ptr<!u16i>
cir.return
diff --git a/clang/test/CIR/IR/invalid-throw.cir b/clang/test/CIR/IR/invalid-throw.cir
index 06a402a68f678..b038c2696d855 100644
--- a/clang/test/CIR/IR/invalid-throw.cir
+++ b/clang/test/CIR/IR/invalid-throw.cir
@@ -5,7 +5,7 @@
module {
cir.func dso_local @throw_without_type_info() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
// expected-error @below {{'cir.throw' op 'type_info' symbol attribute missing}}
cir.throw %0 : !cir.ptr<!s32i>
cir.unreachable
diff --git a/clang/test/CIR/IR/invalid-try-catch.cir b/clang/test/CIR/IR/invalid-try-catch.cir
index f531479cfc7c5..b57b318710547 100644
--- a/clang/test/CIR/IR/invalid-try-catch.cir
+++ b/clang/test/CIR/IR/invalid-try-catch.cir
@@ -59,7 +59,7 @@ cir.func dso_local @invalid_catch_empty_block() {
module {
cir.func dso_local @invalid_catch_not_terminated() {
- %a = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %a = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.scope {
cir.try {
cir.yield
diff --git a/clang/test/CIR/IR/method-attr.cir b/clang/test/CIR/IR/method-attr.cir
index dac9ce6ea7dfc..dbfe867354e32 100644
--- a/clang/test/CIR/IR/method-attr.cir
+++ b/clang/test/CIR/IR/method-attr.cir
@@ -7,7 +7,7 @@
module {
cir.func private @_ZN3Foo2m1Ei(!s32i)
cir.func no_inline dso_local @_Z16make_non_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
- %0 = cir.alloca !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, ["__retval"] {alignment = 8 : i64}
+ %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%1 = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -15,7 +15,7 @@ module {
}
// CHECK: cir.func no_inline dso_local @_Z16make_non_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
-// CHECK: %0 = cir.alloca !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %1 = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
// CHECK: cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -23,7 +23,7 @@ module {
// CHECK: }
cir.func no_inline dso_local @_Z12make_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
- %0 = cir.alloca !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, ["__retval"] {alignment = 8 : i64}
+ %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%1 = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -31,7 +31,7 @@ module {
}
// CHECK: cir.func no_inline dso_local @_Z12make_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
-// CHECK: %0 = cir.alloca !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %1 = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
// CHECK: cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -39,7 +39,7 @@ module {
// CHECK: }
cir.func no_inline dso_local @_Z9make_nullv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
- %0 = cir.alloca !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, ["__retval"] {alignment = 8 : i64}
+ %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%1 = cir.const #cir.method<null> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -47,7 +47,7 @@ module {
}
// CHECK: cir.func no_inline dso_local @_Z9make_nullv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
-// CHECK: %0 = cir.alloca !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %1 = cir.const #cir.method<null> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
// CHECK: cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
diff --git a/clang/test/CIR/IR/resume-flat.cir b/clang/test/CIR/IR/resume-flat.cir
index 79f7b4c827ac7..bb299d6cbbade 100644
--- a/clang/test/CIR/IR/resume-flat.cir
+++ b/clang/test/CIR/IR/resume-flat.cir
@@ -6,16 +6,16 @@
module {
cir.func private @flattened_resume() {
- %exception_addr = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["exception", init] {alignment = 8 : i64}
- %type_id_addr = cir.alloca !u32i, !cir.ptr<!u32i>, ["type_id", init] {alignment = 4 : i64}
+ %exception_addr = cir.alloca "exception" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %type_id_addr = cir.alloca "type_id" align(4) init !u32i -> !cir.ptr<!u32i>
%exception = cir.load %exception_addr : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
%type_id = cir.load %type_id_addr : !cir.ptr<!u32i>, !u32i
cir.resume.flat %exception, %type_id
}
// CHECK: cir.func private @flattened_resume() {
-// CHECK: %[[EXCEPTION_ADDR:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["exception", init]
-// CHECK: %[[TYPE_ID_ADDR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["type_id", init]
+// CHECK: %[[EXCEPTION_ADDR:.*]] = cir.alloca "exception" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CHECK: %[[TYPE_ID_ADDR:.*]] = cir.alloca "type_id" {{.*}} init !u32i -> !cir.ptr<!u32i>
// CHECK: %[[EXCEPTION:.*]] = cir.load %[[EXCEPTION_ADDR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CHECK: %[[TYPE_ID:.*]] = cir.load %[[TYPE_ID_ADDR]] : !cir.ptr<!u32i>, !u32i
// CHECK: cir.resume.flat %[[EXCEPTION]], %[[TYPE_ID]]
diff --git a/clang/test/CIR/IR/struct.cir b/clang/test/CIR/IR/struct.cir
index e8bab7e7746a6..5055896fc9b52 100644
--- a/clang/test/CIR/IR/struct.cir
+++ b/clang/test/CIR/IR/struct.cir
@@ -76,14 +76,14 @@ module {
}
cir.func @structs() {
- %0 = cir.alloca !cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>>, !cir.ptr<!cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>>>, ["sc", init] {alignment = 8 : i64}
- %1 = cir.alloca !cir.ptr<!cir.union<"U" incomplete>>, !cir.ptr<!cir.ptr<!cir.union<"U" incomplete>>>, ["u", init] {alignment = 8 : i64}
+ %0 = cir.alloca "sc" align(8) init cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>> -> !cir.ptr<!cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>>>
+ %1 = cir.alloca "u" align(8) init !cir.ptr<!cir.union<"U" incomplete>> -> !cir.ptr<!cir.ptr<!cir.union<"U" incomplete>>>
cir.return
}
// CHECK: cir.func @structs() {
-// CHECK: %0 = cir.alloca !cir.ptr<!rec_Sc>, !cir.ptr<!cir.ptr<!rec_Sc>>, ["sc", init]
-// CHECK: %1 = cir.alloca !cir.ptr<!rec_U>, !cir.ptr<!cir.ptr<!rec_U>>, ["u", init]
+// CHECK: %0 = cir.alloca "sc" {{.*}} init !cir.ptr<!rec_Sc> -> !cir.ptr<!cir.ptr<!rec_Sc>>
+// CHECK: %1 = cir.alloca "u" {{.*}} init !cir.ptr<!rec_U> -> !cir.ptr<!cir.ptr<!rec_U>>
cir.func @struct_extract_member_test() {
%0 = cir.const #cir.const_record<{#cir.int<1> : !u8i, #cir.int<2> : !u16i, #cir.int<3> : !u32i}> : !rec_Sc
diff --git a/clang/test/CIR/IR/throw.cir b/clang/test/CIR/IR/throw.cir
index 2137309354ad6..135391d338a50 100644
--- a/clang/test/CIR/IR/throw.cir
+++ b/clang/test/CIR/IR/throw.cir
@@ -15,9 +15,9 @@ cir.func @throw_with_no_return() {
// CHECK: }
cir.func @throw_with_no_return_2(%arg0: !s32i, %arg1: !s32i) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
cir.scope {
@@ -38,9 +38,9 @@ cir.func @throw_with_no_return_2(%arg0: !s32i, %arg1: !s32i) -> !s32i {
}
// CHECK: cir.func @throw_with_no_return_2(%[[ARG_0:.*]]: !s32i, %[[ARG_1:.*]]: !s32i) -> !s32i {
-// CHECK: %[[A_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
-// CHECK: %[[B_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
-// CHECK: %[[RES_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK: cir.store %[[ARG_0]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CHECK: cir.store %[[ARG_1]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CHECK: cir.scope {
diff --git a/clang/test/CIR/IR/unary.cir b/clang/test/CIR/IR/unary.cir
index 1ef1606807935..ee41457bf237d 100644
--- a/clang/test/CIR/IR/unary.cir
+++ b/clang/test/CIR/IR/unary.cir
@@ -7,7 +7,7 @@
module {
cir.func @test_unary_unsigned() {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a"] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) !u32i -> !cir.ptr<!u32i>
%1 = cir.load %0 : !cir.ptr<!u32i>, !u32i
%2 = cir.minus %1 : !u32i
%3 = cir.not %1 : !u32i
@@ -16,7 +16,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @test_unary_unsigned() {
-// CHECK: %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "a" align(4) !u32i -> !cir.ptr<!u32i>
// CHECK: %1 = cir.load %0 : !cir.ptr<!u32i>, !u32i
// CHECK: %2 = cir.minus %1 : !u32i
// CHECK: %3 = cir.not %1 : !u32i
@@ -26,7 +26,7 @@ module {
// CHECK: }
cir.func @test_unary_signed() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
%2 = cir.minus nsw %1 : !s32i
%3 = cir.not %1 : !s32i
@@ -35,7 +35,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @test_unary_signed() {
-// CHECK: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
// CHECK: %2 = cir.minus nsw %1 : !s32i
// CHECK: %3 = cir.not %1 : !s32i
diff --git a/clang/test/CIR/IR/vector.cir b/clang/test/CIR/IR/vector.cir
index 7bf1f64ef3100..0182fdd34fec1 100644
--- a/clang/test/CIR/IR/vector.cir
+++ b/clang/test/CIR/IR/vector.cir
@@ -20,33 +20,33 @@ cir.global external @vec_d = #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2>
// CIR-SAME: !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
cir.func @vec_int_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"] {alignment = 16 : i64}
- %1 = cir.alloca !cir.vector<3 x !s32i>, !cir.ptr<!cir.vector<3 x !s32i>>, ["b"] {alignment = 16 : i64}
- %2 = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["c"] {alignment = 8 : i64}
- %3 = cir.alloca !cir.vector<[1] x !s32i>, !cir.ptr<!cir.vector<[1] x !s32i>>, ["d"] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "b" align(16) !cir.vector<3 x !s32i> -> !cir.ptr<!cir.vector<3 x !s32i>>
+ %2 = cir.alloca "c" align(8) !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+ %3 = cir.alloca "d" align(4) !cir.vector<[1] x !s32i> -> !cir.ptr<!cir.vector<[1] x !s32i>>
cir.return
}
// CHECK: cir.func{{.*}} @vec_int_test() {
-// CHECK: %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CHECK: %1 = cir.alloca !cir.vector<3 x !s32i>, !cir.ptr<!cir.vector<3 x !s32i>>, ["b"]
-// CHECK: %2 = cir.alloca !cir.vector<2 x !s32i>, !cir.ptr<!cir.vector<2 x !s32i>>, ["c"]
-// CHECK: %3 = cir.alloca !cir.vector<[1] x !s32i>, !cir.ptr<!cir.vector<[1] x !s32i>>, ["d"]
+// CHECK: %0 = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %1 = cir.alloca "b" {{.*}} !cir.vector<3 x !s32i> -> !cir.ptr<!cir.vector<3 x !s32i>>
+// CHECK: %2 = cir.alloca "c" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CHECK: %3 = cir.alloca "d" {{.*}} !cir.vector<[1] x !s32i> -> !cir.ptr<!cir.vector<[1] x !s32i>>
// CHECK: cir.return
// CHECK: }
cir.func @vec_double_test() {
- %0 = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["a"] {alignment = 16 : i64}
+ %0 = cir.alloca "a" align(16) !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
cir.return
}
// CHECK: cir.func{{.*}} @vec_double_test() {
-// CHECK: %0 = cir.alloca !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>, ["a"]
+// CHECK: %0 = cir.alloca "a" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
// CHECK: cir.return
// CHECK: }
cir.func @local_vector_create_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init] {alignment = 16 : i64}
+ %0 = cir.alloca "a" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
%1 = cir.const #cir.int<1> : !s32i
%2 = cir.const #cir.int<2> : !s32i
%3 = cir.const #cir.int<3> : !s32i
@@ -57,7 +57,7 @@ cir.func @local_vector_create_test() {
}
// CHECK: cir.func{{.*}} @local_vector_create_test() {
-// CHECK: %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CHECK: %0 = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %1 = cir.const #cir.int<1> : !s32i
// CHECK: %2 = cir.const #cir.int<2> : !s32i
// CHECK: %3 = cir.const #cir.int<3> : !s32i
@@ -68,8 +68,8 @@ cir.func @local_vector_create_test() {
// CHECK: }
cir.func @vector_extract_element_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["d", init] {alignment = 16 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init] {alignment = 4 : i64}
+ %0 = cir.alloca "d" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "e" align(4) init !s32i -> !cir.ptr<!s32i>
%2 = cir.const #cir.int<1> : !s32i
%3 = cir.const #cir.int<2> : !s32i
%4 = cir.const #cir.int<3> : !s32i
@@ -84,8 +84,8 @@ cir.func @vector_extract_element_test() {
}
// CHECK: cir.func{{.*}} @vector_extract_element_test() {
-// CHECK: %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["d", init]
-// CHECK: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+// CHECK: %0 = cir.alloca "d" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %1 = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %2 = cir.const #cir.int<1> : !s32i
// CHECK: %3 = cir.const #cir.int<2> : !s32i
// CHECK: %4 = cir.const #cir.int<3> : !s32i
@@ -100,7 +100,7 @@ cir.func @vector_extract_element_test() {
// CHECK: }
cir.func @vector_insert_element_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init] {alignment = 16 : i64}
+ %0 = cir.alloca "a" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
%1 = cir.const #cir.int<1> : !s32i
%2 = cir.const #cir.int<2> : !s32i
%3 = cir.const #cir.int<3> : !s32i
@@ -119,7 +119,7 @@ cir.func @vector_insert_element_test() {
}
// CHECK: cir.func{{.*}} @vector_insert_element_test() {
-// CHECK: %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
+// CHECK: %0 = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %1 = cir.const #cir.int<1> : !s32i
// CHECK: %2 = cir.const #cir.int<2> : !s32i
// CHECK: %3 = cir.const #cir.int<3> : !s32i
@@ -138,9 +138,9 @@ cir.func @vector_insert_element_test() {
// CHECK: }
cir.func @vector_compare_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"] {alignment = 16 : i64}
- %1 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"] {alignment = 16 : i64}
- %2 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["o", init] {alignment = 16 : i64}
+ %0 = cir.alloca "a" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "b" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %2 = cir.alloca "o" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
%3 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
cir.store %3, %0 : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
%4 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
@@ -153,9 +153,9 @@ cir.func @vector_compare_test() {
}
// CHECK: cir.func{{.*}} @vector_compare_test() {
-// CHECK: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CHECK: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CHECK: %[[INIT:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["o", init]
+// CHECK: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[INIT:.*]] = cir.alloca "o" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK: cir.store %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %[[VEC_B_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
@@ -168,9 +168,9 @@ cir.func @vector_compare_test() {
// CHECK: }
cir.func @vector_shuffle_dynamic_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"] {alignment = 16 : i64}
- %1 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"] {alignment = 16 : i64}
- %2 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["r", init] {alignment = 16 : i64}
+ %0 = cir.alloca "a" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "b" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %2 = cir.alloca "r" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
%3 = cir.load align(16) %0 : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
%4 = cir.load align(16) %1 : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
%5 = cir.vec.shuffle.dynamic %3 : !cir.vector<4 x !s32i>, %4 : !cir.vector<4 x !s32i>
@@ -179,9 +179,9 @@ cir.func @vector_shuffle_dynamic_test() {
}
// CHECK: cir.func{{.*}} @vector_shuffle_dynamic_test() {
-// CHECK: %[[VEC_A:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a"]
-// CHECK: %[[VEC_B:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b"]
-// CHECK: %[[RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["r", init]
+// CHECK: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[RES:.*]] = cir.alloca "r" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CHECK: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CHECK: %[[VEC_SHUF:.*]] = cir.vec.shuffle.dynamic %[[TMP_A]] : !cir.vector<4 x !s32i>, %[[TMP_B]] : !cir.vector<4 x !s32i>
@@ -190,8 +190,8 @@ cir.func @vector_shuffle_dynamic_test() {
// CHECK: }
cir.func @vector_splat_test() {
- %0 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init] {alignment = 16 : i64}
- %1 = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init] {alignment = 16 : i64}
+ %0 = cir.alloca "a" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "shl" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
%2 = cir.const #cir.int<1> : !s32i
%3 = cir.const #cir.int<2> : !s32i
%4 = cir.const #cir.int<3> : !s32i
@@ -207,8 +207,8 @@ cir.func @vector_splat_test() {
}
// CHECK: cir.func{{.*}} @vector_splat_test() {
-// CHECK-NEXT: %[[VEC:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CHECK-NEXT: %[[SHL_RES:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["shl", init]
+// CHECK-NEXT: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK-NEXT: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK-NEXT: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
diff --git a/clang/test/CIR/IR/vtable-addrpt.cir b/clang/test/CIR/IR/vtable-addrpt.cir
index ba1c0b8d8c371..a7575e489dbef 100644
--- a/clang/test/CIR/IR/vtable-addrpt.cir
+++ b/clang/test/CIR/IR/vtable-addrpt.cir
@@ -10,7 +10,7 @@
module {
cir.global "private" external @_ZTV1S : !rec_anon_struct {alignment = 8 : i64}
cir.func @_ZN1SC2Ev(%arg0: !cir.ptr<!rec_S>) {
- %0 = cir.alloca !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>, ["this", init] {alignment = 8 : i64}
+ %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
cir.store %arg0, %0 : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
%1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
%2 = cir.vtable.address_point(@_ZTV1S, address_point = <index = 0, offset = 2>) : !cir.vptr
diff --git a/clang/test/CIR/IR/vtt-addrpoint.cir b/clang/test/CIR/IR/vtt-addrpoint.cir
index fe9e29f03901b..5fc1b0b5b97a4 100644
--- a/clang/test/CIR/IR/vtt-addrpoint.cir
+++ b/clang/test/CIR/IR/vtt-addrpoint.cir
@@ -13,8 +13,8 @@ module {
cir.func private @_ZN1AC2Ev(!cir.ptr<!rec_A>)
cir.func private @_ZN1BC2Ev(!cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!void>>)
cir.func dso_local @_ZN1CC2Ev(%arg0: !cir.ptr<!rec_C>, %arg1: !cir.ptr<!cir.ptr<!void>>) {
- %0 = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init] {alignment = 8 : i64}
- %1 = cir.alloca !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, ["vtt", init] {alignment = 8 : i64}
+ %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+ %1 = cir.alloca "vtt" align(8) init !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg1, %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
%2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
@@ -35,7 +35,7 @@ module {
cir.global linkonce_odr dso_local @_ZTV1C = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !rec_anon_struct {alignment = 8 : i64}
cir.global linkonce_odr @_ZTT1C = #cir.const_array<[#cir.global_view<@_ZTV1C, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTC1C0_1B, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 2> {alignment = 8 : i64}
cir.func dso_local @_ZN1CC1Ev(%arg0: !cir.ptr<!rec_C>) {
- %0 = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init] {alignment = 8 : i64}
+ %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
%1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
%2 = cir.base_class_addr %1 : !cir.ptr<!rec_C> nonnull [0] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/Lowering/address-space.cir b/clang/test/CIR/Lowering/address-space.cir
index df203eecdc8e2..f23c138b277df 100644
--- a/clang/test/CIR/Lowering/address-space.cir
+++ b/clang/test/CIR/Lowering/address-space.cir
@@ -25,21 +25,21 @@ module {
// LLVM: define void @foo(ptr %0)
cir.func @foo(%arg0: !cir.ptr<!s32i>) {
// LLVM-NEXT: alloca ptr,
- %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg", init] {alignment = 8 : i64}
+ %0 = cir.alloca "arg" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
cir.return
}
// LLVM: define void @bar(ptr addrspace(1) %0)
cir.func @bar(%arg0: !cir.ptr<!s32i, target_address_space(1)>) {
// LLVM-NEXT: alloca ptr addrspace(1)
- %0 = cir.alloca !cir.ptr<!s32i, target_address_space(1)>, !cir.ptr<!cir.ptr<!s32i, target_address_space(1)>>, ["arg", init] {alignment = 8 : i64}
+ %0 = cir.alloca "arg" align(8) init !cir.ptr<!s32i, target_address_space(1)> -> !cir.ptr<!cir.ptr<!s32i, target_address_space(1)>>
cir.return
}
// LLVM: define void @baz(ptr %0)
cir.func @baz(%arg0: !cir.ptr<!s32i, target_address_space(0)>) {
// LLVM-NEXT: alloca ptr,
- %0 = cir.alloca !cir.ptr<!s32i, target_address_space(0)>, !cir.ptr<!cir.ptr<!s32i, target_address_space(0)>>, ["arg", init] {alignment = 8 : i64}
+ %0 = cir.alloca "arg" align(8) init !cir.ptr<!s32i, target_address_space(0)> -> !cir.ptr<!cir.ptr<!s32i, target_address_space(0)>>
cir.return
}
}
diff --git a/clang/test/CIR/Lowering/alloca.cir b/clang/test/CIR/Lowering/alloca.cir
index c1e6f6f2181c9..ce10ddcf4edd5 100644
--- a/clang/test/CIR/Lowering/alloca.cir
+++ b/clang/test/CIR/Lowering/alloca.cir
@@ -7,7 +7,7 @@ module {
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i64) : i64
// CHECK-NEXT: %{{.*}} = llvm.alloca %[[SIZE]] x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr
cir.func @alloca_i32() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["var_name"] {alignment = 4 : i64}
+ %0 = cir.alloca "var_name" align(4) !s32i -> !cir.ptr<!s32i>
cir.return
}
}
diff --git a/clang/test/CIR/Lowering/binop-bool.cir b/clang/test/CIR/Lowering/binop-bool.cir
index d20883a276c2b..1baa27f395160 100644
--- a/clang/test/CIR/Lowering/binop-bool.cir
+++ b/clang/test/CIR/Lowering/binop-bool.cir
@@ -3,8 +3,8 @@
module {
cir.func @foo() {
- %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !cir.bool -> !cir.ptr<!cir.bool>
+ %1 = cir.alloca "b" align(4) init !cir.bool -> !cir.ptr<!cir.bool>
%2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
%3 = cir.load %1 : !cir.ptr<!cir.bool>, !cir.bool
%4 = cir.or %2, %3 : !cir.bool
diff --git a/clang/test/CIR/Lowering/binop-fp.cir b/clang/test/CIR/Lowering/binop-fp.cir
index a4d5daee0cc07..bfb621e77de18 100644
--- a/clang/test/CIR/Lowering/binop-fp.cir
+++ b/clang/test/CIR/Lowering/binop-fp.cir
@@ -3,12 +3,12 @@
module {
cir.func @foo() {
- %0 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["c"] {alignment = 4 : i64}
- %1 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["d"] {alignment = 4 : i64}
- %2 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["y", init] {alignment = 4 : i64}
- %3 = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["e"] {alignment = 8 : i64}
- %4 = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["f"] {alignment = 8 : i64}
- %5 = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["g", init] {alignment = 8 : i64}
+ %0 = cir.alloca "c" align(4) !cir.float -> !cir.ptr<!cir.float>
+ %1 = cir.alloca "d" align(4) !cir.float -> !cir.ptr<!cir.float>
+ %2 = cir.alloca "y" align(4) init !cir.float -> !cir.ptr<!cir.float>
+ %3 = cir.alloca "e" align(8) !cir.double -> !cir.ptr<!cir.double>
+ %4 = cir.alloca "f" align(8) !cir.double -> !cir.ptr<!cir.double>
+ %5 = cir.alloca "g" align(8) init !cir.double -> !cir.ptr<!cir.double>
%6 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
%7 = cir.load %1 : !cir.ptr<!cir.float>, !cir.float
%8 = cir.mul %6, %7 : !cir.float
diff --git a/clang/test/CIR/Lowering/binop-signed-int.cir b/clang/test/CIR/Lowering/binop-signed-int.cir
index 15bee750e2d7c..26867564df06f 100644
--- a/clang/test/CIR/Lowering/binop-signed-int.cir
+++ b/clang/test/CIR/Lowering/binop-signed-int.cir
@@ -4,9 +4,9 @@
!s32i = !cir.int<s, 32>
module {
cir.func @foo() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
%3 = cir.const #cir.int<2> : !s32i cir.store %3, %0 : !s32i, !cir.ptr<!s32i>
%4 = cir.const #cir.int<1> : !s32i cir.store %4, %1 : !s32i, !cir.ptr<!s32i>
%5 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Lowering/binop-unsigned-int.cir b/clang/test/CIR/Lowering/binop-unsigned-int.cir
index d5545cb7769d4..8f3f3d0c11281 100644
--- a/clang/test/CIR/Lowering/binop-unsigned-int.cir
+++ b/clang/test/CIR/Lowering/binop-unsigned-int.cir
@@ -4,9 +4,9 @@
module {
cir.func @foo() {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
- %1 = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init] {alignment = 4 : i64}
- %2 = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+ %1 = cir.alloca "b" align(4) init !u32i -> !cir.ptr<!u32i>
+ %2 = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
%3 = cir.const #cir.int<2> : !u32i cir.store %3, %0 : !u32i, !cir.ptr<!u32i>
%4 = cir.const #cir.int<1> : !u32i cir.store %4, %1 : !u32i, !cir.ptr<!u32i>
%5 = cir.load %0 : !cir.ptr<!u32i>, !u32i
diff --git a/clang/test/CIR/Lowering/cast.cir b/clang/test/CIR/Lowering/cast.cir
index 19ed51e14519f..8b7351d7fc076 100644
--- a/clang/test/CIR/Lowering/cast.cir
+++ b/clang/test/CIR/Lowering/cast.cir
@@ -12,15 +12,15 @@
module {
cir.func @cStyleCasts(%arg0: !u32i, %arg1: !s32i, %arg2: !cir.float, %arg3: !cir.double) -> !s32i {
// CHECK: llvm.func @cStyleCasts
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["x1", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x2", init] {alignment = 4 : i64}
- %20 = cir.alloca !s16i, !cir.ptr<!s16i>, ["x4", init] {alignment = 2 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
- %3 = cir.alloca !s8i, !cir.ptr<!s8i>, ["a", init] {alignment = 1 : i64}
- %4 = cir.alloca !s16i, !cir.ptr<!s16i>, ["b", init] {alignment = 2 : i64}
- %5 = cir.alloca !s64i, !cir.ptr<!s64i>, ["c", init] {alignment = 8 : i64}
- %6 = cir.alloca !s64i, !cir.ptr<!s64i>, ["d", init] {alignment = 8 : i64}
- %8 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["e", init] {alignment = 8 : i64}
+ %0 = cir.alloca "x1" align(4) init !u32i -> !cir.ptr<!u32i>
+ %1 = cir.alloca "x2" align(4) init !s32i -> !cir.ptr<!s32i>
+ %20 = cir.alloca "x4" align(2) init !s16i -> !cir.ptr<!s16i>
+ %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %3 = cir.alloca "a" align(1) init !s8i -> !cir.ptr<!s8i>
+ %4 = cir.alloca "b" align(2) init !s16i -> !cir.ptr<!s16i>
+ %5 = cir.alloca "c" align(8) init !s64i -> !cir.ptr<!s64i>
+ %6 = cir.alloca "d" align(8) init !s64i -> !cir.ptr<!s64i>
+ %8 = cir.alloca "e" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
@@ -79,8 +79,8 @@ module {
cir.func @testBoolToIntCast(%arg0: !cir.bool) {
// CHECK: llvm.func @testBoolToIntCast
- %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["bl", init] {alignment = 1 : i64}
- %1 = cir.alloca !u8i, !cir.ptr<!u8i>, ["y", init] {alignment = 1 : i64}
+ %0 = cir.alloca "bl" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %1 = cir.alloca "y" align(1) init !u8i -> !cir.ptr<!u8i>
cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
%2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
diff --git a/clang/test/CIR/Lowering/goto.cir b/clang/test/CIR/Lowering/goto.cir
index 30aaf836c7639..86391b5097f15 100644
--- a/clang/test/CIR/Lowering/goto.cir
+++ b/clang/test/CIR/Lowering/goto.cir
@@ -5,8 +5,8 @@
module {
cir.func @gotoFromIf(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%6 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Lowering/inline-asm.cir b/clang/test/CIR/Lowering/inline-asm.cir
index a8545d4c0f059..aad33337a81b2 100644
--- a/clang/test/CIR/Lowering/inline-asm.cir
+++ b/clang/test/CIR/Lowering/inline-asm.cir
@@ -35,7 +35,7 @@ cir.func @f3() {
}
cir.func @f4(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: call void asm sideeffect "", "*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(i32) %2)
cir.asm(x86_att,
@@ -57,7 +57,7 @@ cir.func @f5() {
}
cir.func @f6() -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK: %2 = call i32 asm sideeffect "movl $$42, $0", "=r,~{dirflag},~{fpsr},~{flags}"()
%1 = cir.asm(x86_att,
out = [],
@@ -70,7 +70,7 @@ cir.func @f6() -> !s32i {
}
cir.func @f7(%arg0: !u32i) -> !u32i {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
%1 = cir.load align(4) %0 : !cir.ptr<!u32i>, !u32i
// CHECK: %4 = call i32 asm sideeffect "addl $$42, $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %3)
diff --git a/clang/test/CIR/Lowering/omp-target-map.cir b/clang/test/CIR/Lowering/omp-target-map.cir
index b885cffc2bf48..5bdd8e042fcf5 100644
--- a/clang/test/CIR/Lowering/omp-target-map.cir
+++ b/clang/test/CIR/Lowering/omp-target-map.cir
@@ -9,7 +9,7 @@
module {
// CHECK-LABEL: llvm.func @target_map_from
cir.func @target_map_from(%arg0 : !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: %[[ALLOCA:.*]] = llvm.alloca {{.*}} x i32
diff --git a/clang/test/CIR/Lowering/resume-flat.cir b/clang/test/CIR/Lowering/resume-flat.cir
index 15690db6535ac..d36dda522d1a6 100644
--- a/clang/test/CIR/Lowering/resume-flat.cir
+++ b/clang/test/CIR/Lowering/resume-flat.cir
@@ -6,8 +6,8 @@
module {
cir.func private @flattened_resume() {
- %exception_addr = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["exception", init] {alignment = 8 : i64}
- %type_id_addr = cir.alloca !u32i, !cir.ptr<!u32i>, ["type_id", init] {alignment = 4 : i64}
+ %exception_addr = cir.alloca "exception" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %type_id_addr = cir.alloca "type_id" align(4) init !u32i -> !cir.ptr<!u32i>
%exception = cir.load %exception_addr : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
%type_id = cir.load %type_id_addr : !cir.ptr<!u32i>, !u32i
cir.resume.flat %exception, %type_id
diff --git a/clang/test/CIR/Lowering/switch.cir b/clang/test/CIR/Lowering/switch.cir
index a4f3cc68a3b00..77efee63c5ad6 100644
--- a/clang/test/CIR/Lowering/switch.cir
+++ b/clang/test/CIR/Lowering/switch.cir
@@ -113,7 +113,7 @@ module {
}
cir.func @shouldLowerMultiBlockCase(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -142,9 +142,9 @@ module {
// CHECK: }
cir.func @shouldLowerNestedBreak(%arg0: !s32i, %arg1: !s32i) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
cir.scope {
diff --git a/clang/test/CIR/Lowering/vtt-addrpoint.cir b/clang/test/CIR/Lowering/vtt-addrpoint.cir
index 0fb26f8bfa03c..7932fb51ad8cf 100644
--- a/clang/test/CIR/Lowering/vtt-addrpoint.cir
+++ b/clang/test/CIR/Lowering/vtt-addrpoint.cir
@@ -14,8 +14,8 @@ module {
cir.func private @_ZN1AC2Ev(!cir.ptr<!rec_A>)
cir.func private @_ZN1BC2Ev(!cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!void>>)
cir.func dso_local @_ZN1CC2Ev(%arg0: !cir.ptr<!rec_C>, %arg1: !cir.ptr<!cir.ptr<!void>>) {
- %0 = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init] {alignment = 8 : i64}
- %1 = cir.alloca !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, ["vtt", init] {alignment = 8 : i64}
+ %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+ %1 = cir.alloca "vtt" align(8) init !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg1, %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
%2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
@@ -38,7 +38,7 @@ module {
cir.global linkonce_odr dso_local @_ZTV1C = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !rec_anon_struct {alignment = 8 : i64}
cir.global linkonce_odr @_ZTT1C = #cir.const_array<[#cir.global_view<@_ZTV1C, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTC1C0_1B, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 2> {alignment = 8 : i64}
cir.func dso_local @_ZN1CC1Ev(%arg0: !cir.ptr<!rec_C>) {
- %0 = cir.alloca !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>, ["this", init] {alignment = 8 : i64}
+ %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
%1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
%2 = cir.base_class_addr %1 : !cir.ptr<!rec_C> nonnull [0] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/Transforms/canonicalize.cir b/clang/test/CIR/Transforms/canonicalize.cir
index 26493f7a37e39..35f8e3a64a5d3 100644
--- a/clang/test/CIR/Transforms/canonicalize.cir
+++ b/clang/test/CIR/Transforms/canonicalize.cir
@@ -14,7 +14,7 @@ module {
cir.func @redundant_br() {
cir.br ^bb1
^bb1: // pred: ^bb0
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
%1 = cir.const #cir.int<4> : !u32i
cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
cir.br ^bb2
@@ -22,7 +22,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @redundant_br() {
- // CHECK-NEXT: %[[A:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
+ // CHECK-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
// CHECK-NEXT: %[[FOUR:.*]] = cir.const #cir.int<4> : !u32i
// CHECK-NEXT: cir.store %[[FOUR]], %[[A]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.return
diff --git a/clang/test/CIR/Transforms/complex-create-fold.cir b/clang/test/CIR/Transforms/complex-create-fold.cir
index 918a99686de04..6b1c47494a5ef 100644
--- a/clang/test/CIR/Transforms/complex-create-fold.cir
+++ b/clang/test/CIR/Transforms/complex-create-fold.cir
@@ -4,8 +4,8 @@
module {
cir.func @fold_complex_create_test() -> !cir.complex<!s32i> {
- %0 = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["__retval"] {alignment = 4 : i64}
- %1 = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "__retval" align(4) !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+ %1 = cir.alloca "c" align(4) init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
%2 = cir.const #cir.int<1> : !s32i
%3 = cir.const #cir.int<2> : !s32i
%4 = cir.complex.create %2, %3 : !s32i -> !cir.complex<!s32i>
@@ -17,8 +17,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_complex_create_test() -> !cir.complex<!s32i> {
-// CHECK: %[[RET:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["__retval"]
-// CHECK: %[[INIT:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["c", init]
+// CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
// CHECK: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[TMP:.*]] = cir.load{{.*}} %[[INIT]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
diff --git a/clang/test/CIR/Transforms/complex-imag-fold.cir b/clang/test/CIR/Transforms/complex-imag-fold.cir
index 4955c7d743672..b6cc54e2f5c32 100644
--- a/clang/test/CIR/Transforms/complex-imag-fold.cir
+++ b/clang/test/CIR/Transforms/complex-imag-fold.cir
@@ -4,7 +4,7 @@
module {
cir.func @fold_complex_imag_test() -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
%2 = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
%4 = cir.complex.imag %2 : !cir.complex<!s32i> -> !s32i
cir.store %4, %0 : !s32i, !cir.ptr<!s32i>
@@ -13,7 +13,7 @@ module {
}
// CHECK: cir.func @fold_complex_imag_test() -> !s32i {
- // CHECK: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+ // CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK: %[[IMAG:.*]] = cir.const #cir.int<2> : !s32i
// CHECK: cir.store %[[IMAG]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[TMP:.]] = cir.load %[[RET]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/complex-real-fold.cir b/clang/test/CIR/Transforms/complex-real-fold.cir
index 8ce34719ec654..c95e94968ff67 100644
--- a/clang/test/CIR/Transforms/complex-real-fold.cir
+++ b/clang/test/CIR/Transforms/complex-real-fold.cir
@@ -4,7 +4,7 @@
module {
cir.func @fold_complex_real_test() -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
%2 = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
%4 = cir.complex.real %2 : !cir.complex<!s32i> -> !s32i
cir.store %4, %0 : !s32i, !cir.ptr<!s32i>
@@ -13,7 +13,7 @@ module {
}
// CHECK: cir.func @fold_complex_real_test() -> !s32i {
- // CHECK: %[[RET:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"]
+ // CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK: %[[REAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store %[[REAL]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[TMP:.]] = cir.load %[[RET]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir
index c4c093fff990a..9ba79ce825c6d 100644
--- a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir
+++ b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir
@@ -32,7 +32,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E_ok(
// Only non_trivial_copy is currently supported on Itanium.
cir.func @bad_kind() {
- %0 = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb6
@@ -85,7 +85,7 @@ cir.func private @__clang_cir_catch_copy__ZTS1E_decl(
attributes {cir.eh.catch_copy_thunk}
cir.func @copy_fn_no_body() {
- %0 = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb6
@@ -146,7 +146,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E_multi(
}
cir.func @multi_block_thunk() {
- %0 = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb6
diff --git a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir
index 14d2c5b086a7c..5388953701515 100644
--- a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir
+++ b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir
@@ -56,7 +56,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E(
}
cir.func @test_basic_construct_catch() {
- %0 = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb7
@@ -131,7 +131,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E_shared(
}
cir.func @test_shared_thunk_caller_a() {
- %0 = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb7
@@ -158,7 +158,7 @@ cir.func @test_shared_thunk_caller_a() {
}
cir.func @test_shared_thunk_caller_b() {
- %0 = cir.alloca !rec_E, !cir.ptr<!rec_E>, ["e"] {alignment = 1 : i64}
+ %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb7
diff --git a/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir b/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir
index 2abbeae61f23b..007fdc5bdd3a0 100644
--- a/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir
+++ b/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir
@@ -19,7 +19,7 @@ module attributes {cir.triple = "x86_64-unknown-linux-gnu"} {
// cir.begin_cleanup / cir.end_cleanup → removed
// cir.resume → cir.resume.flat
cir.func @test_cleanup_only() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try_call @doSomething(%0) ^bb1, ^bb2 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
@@ -253,7 +253,7 @@ cir.func @test_multiple_typed_and_catch_all() {
// Two landing pads: one without cleanup (ctor), one with cleanup (doSomething).
// cleanup ops are removed, cleanup code stays.
cir.func @test_catch_with_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.try_call @ctor(%0) ^bb1, ^bb3 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
cir.try_call @doSomething(%0) ^bb2, ^bb4 : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -333,7 +333,7 @@ cir.func @test_catch_with_cleanup() {
// Having a typed catch in the dispatch causes both eh.initiate sites to
// include @_ZTISt9exception in their catch_type_list.
cir.func @test_typed_catch_with_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.try_call @ctor(%0) ^bb1, ^bb3 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
cir.try_call @doSomething(%0) ^bb2, ^bb4 : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -427,7 +427,7 @@ cir.func @test_typed_catch_with_cleanup() {
cir.func no_inline dso_local @test_catch_with_cleanup_no_ctor() personality(@__gxx_personality_v0) {
cir.br ^bb1
^bb1: // pred: ^bb0
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["s"] {alignment = 1 : i64}
+ %0 = cir.alloca "s" align(1) !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.br ^bb2
^bb2: // pred: ^bb1
cir.try_call @mayThrow() ^bb3, ^bb4 : () -> ()
@@ -503,7 +503,7 @@ cir.func no_inline dso_local @test_catch_with_cleanup_no_ctor() personality(@__g
// This represents the case where an exception is thrown during cleanup code
// (e.g., a destructor that throws while another exception is being unwound).
cir.func @test_eh_terminate() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try_call @doSomething(%0) ^bb1, ^bb2 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir
index eb8e1aafa7ac4..78b4cd0d8337a 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir
@@ -12,7 +12,7 @@
// exception-throwing calls are replaced with try_call and unwind to an
// EH cleanup block that performs the cleanup and resumes unwinding.
cir.func @test_eh_only_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -25,7 +25,7 @@ cir.func @test_eh_only_cleanup() {
}
// CHECK-LABEL: cir.func @test_eh_only_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -53,7 +53,7 @@ cir.func @test_eh_only_cleanup() {
// Test cleanup kind "all" flattening. Normal exits go through the normal
// cleanup path, and exception-throwing calls unwind to an EH cleanup block.
cir.func @test_all_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -66,7 +66,7 @@ cir.func @test_all_cleanup() {
}
// CHECK-LABEL: cir.func @test_all_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -101,7 +101,7 @@ cir.func @test_all_cleanup() {
// Test EH cleanup with multiple calls that may throw. Each call becomes a
// try_call, and all unwind to the same shared unwind block.
cir.func @test_eh_cleanup_multiple_calls() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -115,7 +115,7 @@ cir.func @test_eh_cleanup_multiple_calls() {
}
// CHECK-LABEL: cir.func @test_eh_cleanup_multiple_calls()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -147,7 +147,7 @@ cir.func @test_eh_cleanup_multiple_calls() {
// Test that nothrow calls are NOT replaced with try_call.
cir.func @test_eh_cleanup_nothrow_call() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -161,7 +161,7 @@ cir.func @test_eh_cleanup_nothrow_call() {
}
// CHECK-LABEL: cir.func @test_eh_cleanup_nothrow_call()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -189,8 +189,8 @@ cir.func @test_eh_cleanup_nothrow_call() {
// Test EH cleanup with a call that returns a value.
cir.func @test_eh_cleanup_call_with_result() -> !s32i {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%2 = cir.call @get() : () -> !s32i
@@ -205,8 +205,8 @@ cir.func @test_eh_cleanup_call_with_result() -> !s32i {
}
// CHECK-LABEL: cir.func @test_eh_cleanup_call_with_result()
-// CHECK: %[[ALLOCA_CLASS:.*]] = cir.alloca !rec_SomeClass
-// CHECK: %[[ALLOCA_RET:.*]] = cir.alloca !s32i
+// CHECK: %[[ALLOCA_CLASS:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA_RET:.*]] = cir.alloca {{.*}} !s32i
// CHECK: cir.call @ctor(%[[ALLOCA_CLASS]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -236,8 +236,8 @@ cir.func @test_eh_cleanup_call_with_result() -> !s32i {
// Then the cleanup scope flattening must handle cloning the multi-block
// cleanup region for the EH path.
cir.func @test_nrvo() -> !rec_NonTrivial {
- %0 = cir.alloca !rec_NonTrivial, !cir.ptr<!rec_NonTrivial>, ["__retval"] {alignment = 1 : i64}
- %1 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["nrvo"] {alignment = 1 : i64}
+ %0 = cir.alloca "__retval" align(1) !rec_NonTrivial -> !cir.ptr<!rec_NonTrivial>
+ %1 = cir.alloca "nrvo" align(1) !cir.bool -> !cir.ptr<!cir.bool>
cir.cleanup.scope {
%2 = cir.const #false
cir.store align(1) %2, %1 : !cir.bool, !cir.ptr<!cir.bool>
@@ -258,8 +258,8 @@ cir.func @test_nrvo() -> !rec_NonTrivial {
}
// CHECK-LABEL: cir.func @test_nrvo()
-// CHECK: %[[RETVAL:.*]] = cir.alloca !rec_NonTrivial
-// CHECK: %[[NRVO:.*]] = cir.alloca !cir.bool
+// CHECK: %[[RETVAL:.*]] = cir.alloca {{.*}} !rec_NonTrivial
+// CHECK: %[[NRVO:.*]] = cir.alloca {{.*}} !cir.bool
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
// Body: store false to nrvo flag, try_call maybeThrow.
@@ -321,7 +321,7 @@ cir.func @test_nrvo() -> !rec_NonTrivial {
// In this case, the unwind from the EH cleanup can be left to unwind to
// callers.
cir.func @test_eh_cleanup_in_try() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try {
cir.cleanup.scope {
@@ -337,7 +337,7 @@ cir.func @test_eh_cleanup_in_try() {
}
// CHECK: cir.func @test_eh_cleanup_in_try()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init]
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[TRY_BODY:bb[0-9]+]]
//
@@ -383,8 +383,8 @@ cir.func @test_eh_cleanup_in_try() {
// doSomething(&c);
// }
cir.func @test_nested_eh_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -404,8 +404,8 @@ cir.func @test_nested_eh_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_eh_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init]
-// CHECK: %[[C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init]
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
//
@@ -488,8 +488,8 @@ cir.func @test_nested_eh_cleanup() {
// }
// };
cir.func @test_nested_eh_only_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["base", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "base" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -509,8 +509,8 @@ cir.func @test_nested_eh_only_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_eh_only_cleanup()
-// CHECK: %[[BASE:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["base", init]
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init]
+// CHECK: %[[BASE:.*]] = cir.alloca "base" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[BASE]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
//
@@ -586,8 +586,8 @@ cir.func @test_nested_eh_only_cleanup() {
// doSomethingElse(&c);
// }
cir.func @test_nested_eh_both_throwing() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -608,8 +608,8 @@ cir.func @test_nested_eh_both_throwing() {
}
// CHECK-LABEL: cir.func @test_nested_eh_both_throwing()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init]
-// CHECK: %[[C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init]
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
//
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir
index 11e19a4b932e2..1b1ca993a2461 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir
@@ -7,7 +7,7 @@
// Test that a cleanup scope with break that branches through cleanup is
// properly flattened with a destination slot and switch dispatch.
cir.func @test_multi_exit_with_break() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -30,8 +30,8 @@ cir.func @test_multi_exit_with_break() {
}
// CHECK-LABEL: cir.func @test_multi_exit_with_break()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -77,7 +77,7 @@ cir.func private @shouldBreak() -> !cir.bool
// Test that a cleanup scope with continue that branches through cleanup is
// properly flattened.
cir.func @test_multi_exit_with_continue() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -100,8 +100,8 @@ cir.func @test_multi_exit_with_continue() {
}
// CHECK-LABEL: cir.func @test_multi_exit_with_continue()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -144,7 +144,7 @@ cir.func private @shouldContinue() -> !cir.bool
// Test continue inside a switch that's inside a cleanup scope.
cir.func @test_continue_in_switch() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -172,8 +172,8 @@ cir.func @test_continue_in_switch() {
}
// CHECK-LABEL: cir.func @test_continue_in_switch()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -221,7 +221,7 @@ cir.func @test_continue_in_switch() {
// Test return inside a loop inside a switch inside a cleanup scope.
cir.func @test_return_in_loop_in_switch() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -258,8 +258,8 @@ cir.func @test_return_in_loop_in_switch() {
}
// CHECK-LABEL: cir.func @test_return_in_loop_in_switch()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -318,8 +318,8 @@ cir.func private @shouldReturn() -> !cir.bool
// Test return inside nested cleanup scopes - both need multi-exit handling.
cir.func @test_return_in_nested_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -343,9 +343,9 @@ cir.func @test_return_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_return_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1"
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2"
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -403,8 +403,8 @@ cir.func @test_return_in_nested_cleanup() {
// Test return inside nested cleanup scopes.
cir.func @test_return_constant_in_nested_cleanup() -> !s32i {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -430,9 +430,9 @@ cir.func @test_return_constant_in_nested_cleanup() -> !s32i {
}
// CHECK-LABEL: cir.func @test_return_constant_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init]
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init]
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -492,8 +492,8 @@ cir.func @test_return_constant_in_nested_cleanup() -> !s32i {
// Test return with computed value.
cir.func @test_return_computed_value(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -520,10 +520,10 @@ cir.func @test_return_computed_value(%arg0: !s32i) -> !s32i {
// CHECK-LABEL: cir.func @test_return_computed_value
// CHECK-SAME: (%[[ARG0:.*]]: !s32i)
-// CHECK: %[[RET_TMP:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__ret_operand_tmp"]
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init]
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init]
+// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -585,8 +585,8 @@ cir.func @test_return_computed_value(%arg0: !s32i) -> !s32i {
// Test return with of a function parameter value.
cir.func @test_return_param_value(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -612,10 +612,10 @@ cir.func @test_return_param_value(%arg0: !s32i) -> !s32i {
// CHECK-LABEL: cir.func @test_return_param_value
// CHECK-SAME: (%[[ARG0:.*]]: !s32i)
-// CHECK: %[[RET_TMP:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__ret_operand_tmp"]
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init]
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init]
+// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -676,8 +676,8 @@ cir.func @test_return_param_value(%arg0: !s32i) -> !s32i {
// Test return of a block argument value.
cir.func @test_return_blockarg_value(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -705,10 +705,10 @@ cir.func @test_return_blockarg_value(%arg0: !s32i) -> !s32i {
// CHECK-LABEL: cir.func @test_return_blockarg_value
// CHECK-SAME: (%[[ARG0:.*]]: !s32i)
-// CHECK: %[[RET_TMP:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__ret_operand_tmp"]
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init]
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init]
+// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -771,8 +771,8 @@ cir.func @test_return_blockarg_value(%arg0: !s32i) -> !s32i {
// Test break inside nested cleanup scopes within a loop.
cir.func @test_break_in_nested_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -802,9 +802,9 @@ cir.func @test_break_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_break_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1"
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2"
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -869,8 +869,8 @@ cir.func @test_break_in_nested_cleanup() {
// Test continue inside nested cleanup scopes within a loop.
cir.func @test_continue_in_nested_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -900,9 +900,9 @@ cir.func @test_continue_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_continue_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1"
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2"
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -967,9 +967,9 @@ cir.func @test_continue_in_nested_cleanup() {
// Test continue inside nested cleanup in switch.
cir.func @test_continue_in_nested_cleanup_in_switch() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %2 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -1001,10 +1001,10 @@ cir.func @test_continue_in_nested_cleanup_in_switch() {
}
// CHECK-LABEL: cir.func @test_continue_in_nested_cleanup_in_switch()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1"
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2"
-// CHECK: %[[ALLOCA_X:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_X:.*]] = cir.alloca "x" {{.*}} !s32i -> !cir.ptr<!s32i>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -1057,7 +1057,7 @@ cir.func @test_continue_in_nested_cleanup_in_switch() {
// Test return inside loop inside cleanup scope.
cir.func @test_return_in_loop_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.while {
@@ -1080,8 +1080,8 @@ cir.func @test_return_in_loop_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_return_in_loop_in_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[CLEANUP_BODY:bb[0-9]+]]
// CHECK: ^[[CLEANUP_BODY]]:
@@ -1128,7 +1128,7 @@ cir.func private @shouldGoto() -> !cir.bool
// switch routes the goto's destination id to a block containing a new
// cir.goto to the same label.
cir.func @test_multi_exit_with_goto() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%cond = cir.call @shouldGoto() : () -> !cir.bool
@@ -1148,8 +1148,8 @@ cir.func @test_multi_exit_with_goto() {
}
// CHECK-LABEL: cir.func @test_multi_exit_with_goto()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -1188,8 +1188,8 @@ cir.func @test_multi_exit_with_goto() {
// scopes. The goto must branch through both cleanups before reaching its
// target. Each cleanup re-emits the goto via its dispatch destination block.
cir.func @test_goto_in_nested_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -1218,9 +1218,9 @@ cir.func @test_goto_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["__cleanup_dest_slot", cleanup_dest_slot]
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1"
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2"
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
index 63eda52b90a62..30dd1e88e3e01 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
@@ -7,7 +7,7 @@
// Test basic cleanup scope flattening with normal cleanup.
// The body yields to cleanup, cleanup yields to continue.
cir.func @test_normal_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -20,7 +20,7 @@ cir.func @test_normal_cleanup() {
}
// CHECK-LABEL: cir.func @test_normal_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -34,7 +34,7 @@ cir.func @test_normal_cleanup() {
// Test that a single return from the cleanup body branches through the cleanup.
cir.func @test_return_from_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -47,7 +47,7 @@ cir.func @test_return_from_cleanup() {
}
// CHECK-LABEL: cir.func @test_return_from_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -63,7 +63,7 @@ cir.func @test_return_from_cleanup() {
// Test that a single return from the cleanup body branches through the cleanup.
cir.func @test_return_from_cleanup_with_operand() -> !s32i {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -78,7 +78,7 @@ cir.func @test_return_from_cleanup_with_operand() -> !s32i {
}
// CHECK-LABEL: cir.func @test_return_from_cleanup_with_operand()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -97,7 +97,7 @@ cir.func @test_return_from_cleanup_with_operand() -> !s32i {
// Test that a continue statement in a cleanup scope branches through the
// cleanup block before continuing the loop.
cir.func @test_continue_in_cleanup_in_loop() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%cond = cir.call @shouldContinue() : () -> !cir.bool
cir.condition(%cond)
@@ -120,7 +120,7 @@ cir.func @test_continue_in_cleanup_in_loop() {
}
// CHECK-LABEL: cir.func @test_continue_in_cleanup_in_loop()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[COND1:.*]] = cir.call @shouldContinue() : () -> !cir.bool
@@ -146,7 +146,7 @@ cir.func @test_continue_in_cleanup_in_loop() {
// Test that a break statement in a cleanup scope branches through the
// cleanup block before breaking out of the loop.
cir.func @test_break_in_cleanup_in_loop() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.while {
%cond = cir.call @shouldContinue() : () -> !cir.bool
cir.condition(%cond)
@@ -169,7 +169,7 @@ cir.func @test_break_in_cleanup_in_loop() {
}
// CHECK-LABEL: cir.func @test_break_in_cleanup_in_loop()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[COND1:.*]] = cir.call @shouldContinue() : () -> !cir.bool
@@ -194,8 +194,8 @@ cir.func @test_break_in_cleanup_in_loop() {
// Test nested cleanup scopes.
cir.func @test_nested_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -215,8 +215,8 @@ cir.func @test_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_cleanup()
-// CHECK: %[[ALLOCA1:.*]] = cir.alloca !rec_SomeClass
-// CHECK: %[[ALLOCA2:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA1:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA2:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -239,7 +239,7 @@ cir.func @test_nested_cleanup() {
// Test a switch within a cleanup scope where the switch does not branch
// through the cleanup.
cir.func @test_normal_cleanup_with_switch() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%1 = cir.call @get() : () -> !s32i
@@ -262,7 +262,7 @@ cir.func @test_normal_cleanup_with_switch() {
}
// CHECK-LABEL: cir.func @test_normal_cleanup_with_switch()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -292,7 +292,7 @@ cir.func @test_normal_cleanup_with_switch() {
// handled by the loop itself, so only the yield after the loop exits through
// the cleanup.
cir.func @test_loop_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.while {
@@ -315,7 +315,7 @@ cir.func @test_loop_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_loop_in_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[LOOP_BEGIN:bb[0-9]+]]
// CHECK: ^[[LOOP_BEGIN]]:
@@ -342,7 +342,7 @@ cir.func @test_loop_in_cleanup() {
// handled by the switch, the loop's break/continue are handled by the loop,
// so only the yield exits through cleanup.
cir.func @test_switch_in_loop_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.while {
@@ -370,7 +370,7 @@ cir.func @test_switch_in_loop_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_switch_in_loop_in_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[LOOP_BEGIN:bb[0-9]+]]
// CHECK: ^[[LOOP_BEGIN]]:
@@ -404,7 +404,7 @@ cir.func @test_switch_in_loop_in_cleanup() {
// are handled by the loop, the switch's break exits the switch, so only the
// yield exits through cleanup.
cir.func @test_loop_in_switch_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%x = cir.call @get() : () -> !s32i
@@ -434,7 +434,7 @@ cir.func @test_loop_in_switch_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_loop_in_switch_in_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -472,8 +472,8 @@ cir.func @test_loop_in_switch_in_cleanup() {
// scope with a break. The break is handled by the switch, so the outer cleanup
// has only one exit (yield) and should flatten successfully.
cir.func @test_nested_cleanup_break_in_switch() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%x = cir.call @get() : () -> !s32i
@@ -500,8 +500,8 @@ cir.func @test_nested_cleanup_break_in_switch() {
}
// CHECK-LABEL: cir.func @test_nested_cleanup_break_in_switch()
-// CHECK: %[[ALLOCA1:.*]] = cir.alloca !rec_SomeClass
-// CHECK: %[[ALLOCA2:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA1:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA2:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA1]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -537,7 +537,7 @@ cir.func @test_nested_cleanup_break_in_switch() {
// the yield at the end of the body, so the cleanup runs once after the goto's
// destination is reached.
cir.func @test_goto_within_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%cond = cir.call @shouldGoto() : () -> !cir.bool
@@ -558,7 +558,7 @@ cir.func @test_goto_within_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_within_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -583,8 +583,8 @@ cir.func @test_goto_within_cleanup() {
// exit; the inner cleanup runs once after the goto's destination is reached
// and the outer cleanup runs once on normal exit from the inner cleanup.
cir.func @test_goto_within_nested_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -612,8 +612,8 @@ cir.func @test_goto_within_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_within_nested_cleanup()
-// CHECK: %[[A1:.*]] = cir.alloca !rec_SomeClass{{.*}}["c1"
-// CHECK: %[[A2:.*]] = cir.alloca !rec_SomeClass{{.*}}["c2"
+// CHECK: %[[A1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass{{.*}}
+// CHECK: %[[A2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass{{.*}}
// CHECK: cir.call @ctor(%[[A1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -646,7 +646,7 @@ cir.func @test_goto_within_nested_cleanup() {
// body branches to cleanup entry, the cleanup runs and then a goto with the
// same target label is emitted in the cleanup continuation block.
cir.func @test_goto_out_of_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -662,7 +662,7 @@ cir.func @test_goto_out_of_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_out_of_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
diff --git a/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir b/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir
index f7831ba3c2df3..26da1238ec2cd 100644
--- a/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir
+++ b/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir
@@ -8,7 +8,7 @@
// Test that a throwing call in an EH cleanup region is replaced with
// cir.try_call that unwinds to a terminate block.
cir.func @test_throwing_dtor_in_eh_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -55,7 +55,7 @@ cir.func @test_throwing_dtor_in_eh_cleanup() {
// On the EH cleanup path, the call is replaced with try_call → terminate.
// On the normal cleanup path, the call remains a regular cir.call.
cir.func @test_throwing_dtor_in_all_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -95,7 +95,7 @@ cir.func @test_throwing_dtor_in_all_cleanup() {
// Test throwing call in EH cleanup within a try operation.
cir.func @test_throwing_dtor_in_eh_cleanup_in_try() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try {
cir.cleanup.scope {
@@ -130,8 +130,8 @@ cir.func @test_throwing_dtor_in_eh_cleanup_in_try() {
// Test multiple throwing calls in the cleanup region.
cir.func @test_multiple_throwing_calls_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c1", init] {alignment = 4 : i64}
- %1 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c2", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
diff --git a/clang/test/CIR/Transforms/flatten-try-op.cir b/clang/test/CIR/Transforms/flatten-try-op.cir
index 3c2ed27ce4c8b..580849aa183fc 100644
--- a/clang/test/CIR/Transforms/flatten-try-op.cir
+++ b/clang/test/CIR/Transforms/flatten-try-op.cir
@@ -9,7 +9,7 @@
// Test a simple try with no handlers and no throwing calls.
cir.func @test_try_no_handlers() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.scope {
cir.try {
%1 = cir.const #cir.int<1> : !s32i
@@ -21,7 +21,7 @@ cir.func @test_try_no_handlers() {
}
// CHECK-LABEL: cir.func @test_try_no_handlers()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca !s32i
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !s32i
// CHECK: cir.br ^[[SCOPE:bb[0-9]+]]
// CHECK: ^[[SCOPE]]:
// CHECK: cir.br ^[[TRY_BODY:bb[0-9]+]]
@@ -86,7 +86,7 @@ cir.func @test_try_catch_all() {
// If the exception type doesn't match, control goes to the unwind handler
// which resumes unwinding.
cir.func @test_try_catch_typed_with_unwind() {
- %0 = cir.alloca !cir.ptr<!rec_exception>, !cir.ptr<!cir.ptr<!rec_exception>>, ["e"] {alignment = 8 : i64}
+ %0 = cir.alloca "e" align(8) !cir.ptr<!rec_exception> -> !cir.ptr<!cir.ptr<!rec_exception>>
cir.scope {
cir.try {
cir.call @mayThrow() : () -> ()
@@ -103,7 +103,7 @@ cir.func @test_try_catch_typed_with_unwind() {
}
// CHECK-LABEL: cir.func @test_try_catch_typed_with_unwind()
-// CHECK: %[[E_ALLOCA:.*]] = cir.alloca !cir.ptr<!rec_std3A3Aexception>
+// CHECK: %[[E_ALLOCA:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_std3A3Aexception>
// CHECK: cir.br ^[[SCOPE:bb[0-9]+]]
//
// CHECK: ^[[SCOPE]]:
@@ -142,7 +142,7 @@ cir.func @test_try_catch_typed_with_unwind() {
// are chained to the catch dispatch block of the enclosing try.
cir.func @test_try_catch_with_cleanup() {
cir.scope {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.try {
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
@@ -163,7 +163,7 @@ cir.func @test_try_catch_with_cleanup() {
}
// CHECK-LABEL: cir.func @test_try_catch_with_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[TRY_BODY:bb[0-9]+]]
//
// CHECK: ^[[TRY_BODY]]:
@@ -221,8 +221,8 @@ cir.func @test_try_catch_with_cleanup() {
// by the try's handlers, the resume from the unwind handler should chain
// to the outer cleanup's EH handler.
cir.func @test_try_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
- %1 = cir.alloca !cir.ptr<!rec_exception>, !cir.ptr<!cir.ptr<!rec_exception>>, ["e"] {alignment = 8 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "e" align(8) !cir.ptr<!rec_exception> -> !cir.ptr<!cir.ptr<!rec_exception>>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.scope {
@@ -246,8 +246,8 @@ cir.func @test_try_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_try_in_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass
-// CHECK: %[[E:.*]] = cir.alloca !cir.ptr<!rec_std3A3Aexception>
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[E:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_std3A3Aexception>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[OUTER_CLEANUP_BODY:bb[0-9]+]]
//
@@ -473,7 +473,7 @@ cir.func @test_nested_try() {
// scope inside a catch handler. This is the form of the catch handler that will
// actually be generated. The representations above are all simplifications.
cir.func @test_try_with_handlers_in_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.try {
@@ -498,7 +498,7 @@ cir.func @test_try_with_handlers_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_try_with_handlers_in_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[CLEANUP_BODY:bb[0-9]+]]
//
@@ -543,7 +543,7 @@ cir.func @test_try_with_handlers_in_cleanup() {
// The inner try's unwind handler must execute the cleanup (dtor) before
// the exception reaches the outer try's catch dispatch.
cir.func @test_nested_try_with_cleanup() {
- %0 = cir.alloca !rec_SomeClass, !cir.ptr<!rec_SomeClass>, ["c", init] {alignment = 4 : i64}
+ %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
cir.scope {
cir.try {
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -574,7 +574,7 @@ cir.func @test_nested_try_with_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_try_with_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca !rec_SomeClass
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
// CHECK: cir.br ^[[SCOPE:bb[0-9]+]]
//
// CHECK: ^[[SCOPE]]:
diff --git a/clang/test/CIR/Transforms/goto_solver.cir b/clang/test/CIR/Transforms/goto_solver.cir
index 6ae019b44a39e..b41f498ec33db 100644
--- a/clang/test/CIR/Transforms/goto_solver.cir
+++ b/clang/test/CIR/Transforms/goto_solver.cir
@@ -3,7 +3,7 @@
!void = !cir.void
cir.func @a(){
- %0 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init] {alignment = 8 : i64}
+ %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
%1 = cir.block_address <@a, "label1"> : !cir.ptr<!void>
cir.store align(8) %1, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
cir.br ^bb1
@@ -25,7 +25,7 @@ cir.func @a(){
// CHECK-NOT: cir.label "label2"
cir.func @b(){
- %0 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init] {alignment = 8 : i64}
+ %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
%1 = cir.block_address <@b, "label1"> : !cir.ptr<!void>
cir.store align(8) %1, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
cir.goto "label2"
@@ -50,7 +50,7 @@ cir.func @b(){
cir.func @c() {
cir.label "label1"
- %0 = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["ptr", init] {alignment = 8 : i64}
+ %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
%1 = cir.block_address <@c, "label1"> : !cir.ptr<!void>
cir.store align(8) %1, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
cir.return
diff --git a/clang/test/CIR/Transforms/hoist-allocas.cir b/clang/test/CIR/Transforms/hoist-allocas.cir
index 04724f3073e57..b0a8b15e00aa8 100644
--- a/clang/test/CIR/Transforms/hoist-allocas.cir
+++ b/clang/test/CIR/Transforms/hoist-allocas.cir
@@ -6,7 +6,7 @@
module {
cir.func @l1() {
cir.scope {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+ %0 = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
%1 = cir.const #cir.int<0> : !s32i
cir.store %1, %0 : !s32i, !cir.ptr<!s32i>
cir.for : cond {
@@ -21,7 +21,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @l1
- // CHECK-NEXT: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+ // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store %[[ZERO]], %[[I]] : !s32i, !cir.ptr<!s32i>
@@ -44,7 +44,7 @@ module {
cir.condition(%0)
} body {
cir.scope {
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+ %1 = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
%2 = cir.const #cir.int<0> : !s32i
cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
}
@@ -56,7 +56,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @l2
- // CHECK-NEXT: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+ // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
@@ -81,7 +81,7 @@ module {
cir.condition(%0)
} body {
cir.scope {
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init, const] {alignment = 4 : i64}
+ %1 = cir.alloca "i" align(4) init const !s32i -> !cir.ptr<!s32i>
%2 = cir.const #cir.int<0> : !s32i
cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
}
@@ -93,7 +93,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @l3
- // CHECK-NEXT: %[[I:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["i", init] {alignment = 4 : i64}
+ // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
diff --git a/clang/test/CIR/Transforms/mem2reg.cir b/clang/test/CIR/Transforms/mem2reg.cir
index 872b5212a1244..87d9b970e4b4b 100644
--- a/clang/test/CIR/Transforms/mem2reg.cir
+++ b/clang/test/CIR/Transforms/mem2reg.cir
@@ -11,8 +11,8 @@ module {
cir.func @promote_simple_stack_slots() -> !s32i {
// CHECK: %[[CONST:.*]] = cir.const #cir.int<42>
// CHECK: cir.return %[[CONST]]
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
+ %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
%2 = cir.const #cir.int<42> : !s32i
cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
%3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/scope.cir b/clang/test/CIR/Transforms/scope.cir
index 757428cd019ac..22bfdb246ba70 100644
--- a/clang/test/CIR/Transforms/scope.cir
+++ b/clang/test/CIR/Transforms/scope.cir
@@ -5,7 +5,7 @@
module {
cir.func @foo() {
cir.scope {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
%1 = cir.const #cir.int<4> : !u32i
cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
}
@@ -14,7 +14,7 @@ module {
// CHECK: cir.func{{.*}} @foo() {
// CHECK: cir.br ^bb1
// CHECK: ^bb1: // pred: ^bb0
-// CHECK: %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
// CHECK: %1 = cir.const #cir.int<4> : !u32i
// CHECK: cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
// CHECK: cir.br ^bb2
@@ -33,7 +33,7 @@ module {
// CHECK: }
cir.func @scope_with_return() -> !u32i {
- %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "__retval" align(4) !u32i -> !cir.ptr<!u32i>
cir.scope {
%2 = cir.const #cir.int<0> : !u32i
cir.store %2, %0 : !u32i, !cir.ptr<!u32i>
@@ -45,7 +45,7 @@ module {
}
// CHECK: cir.func{{.*}} @scope_with_return() -> !u32i {
-// CHECK: %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(4) !u32i -> !cir.ptr<!u32i>
// CHECK: cir.br ^bb1
// CHECK: ^bb1: // pred: ^bb0
// CHECK: %1 = cir.const #cir.int<0> : !u32i
diff --git a/clang/test/CIR/Transforms/switch-fold.cir b/clang/test/CIR/Transforms/switch-fold.cir
index c348a05128671..7b4e59718ec86 100644
--- a/clang/test/CIR/Transforms/switch-fold.cir
+++ b/clang/test/CIR/Transforms/switch-fold.cir
@@ -5,7 +5,7 @@
module {
cir.func @foldCascade(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -37,7 +37,7 @@ module {
//CHECK-NEXT: }
cir.func @foldCascade2(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -76,10 +76,10 @@ module {
//CHECK: cir.yield
//CHECK: }
cir.func @foldCascade3(%arg0: !s32i ) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"] {alignment = 4 : i64}
+ %1 = cir.alloca "x" align(4) !s32i -> !cir.ptr<!s32i>
%2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
cir.switch (%2 : !s32i) {
cir.case(equal, [#cir.int<0> : !s32i]) {
@@ -113,7 +113,7 @@ module {
//CHECK: cir.yield
//CHECK: }
cir.func @foldCascadeWithDefault(%arg0: !s32i ) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -158,7 +158,7 @@ module {
//CHECK: cir.yield
//CHECK: }
cir.func @foldAllCascade(%arg0: !s32i ) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/switch.cir b/clang/test/CIR/Transforms/switch.cir
index 42a5484e77388..2a96c60896be5 100644
--- a/clang/test/CIR/Transforms/switch.cir
+++ b/clang/test/CIR/Transforms/switch.cir
@@ -127,7 +127,7 @@ module {
cir.func @shouldFlatMultiBlockCase(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -144,7 +144,7 @@ module {
}
// CHECK: cir.func{{.*}} @shouldFlatMultiBlockCase(%arg0: !s32i) {
-// CHECK: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
// CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: cir.br ^bb1
// CHECK: ^bb1: // pred: ^bb0
@@ -162,9 +162,9 @@ module {
cir.func @shouldFlatNestedBreak(%arg0: !s32i, %arg1: !s32i) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
cir.scope {
@@ -211,9 +211,9 @@ module {
cir.func @flatCaseRange(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
- %2 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
%3 = cir.const #cir.int<0> : !s32i
cir.store %3, %2 : !s32i, !cir.ptr<!s32i>
@@ -275,7 +275,7 @@ module {
// CHECK: }
cir.func @_Z8bigRangei(%arg0: !s32i) {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/ternary-fold.cir b/clang/test/CIR/Transforms/ternary-fold.cir
index 02d450b4d93de..245cd01e7d35c 100644
--- a/clang/test/CIR/Transforms/ternary-fold.cir
+++ b/clang/test/CIR/Transforms/ternary-fold.cir
@@ -51,7 +51,7 @@ module {
// CHECK-NEXT: }
cir.func @non_simplifiable_ternary(%arg0 : !cir.bool) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] {alignment = 4 : i64}
+ %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
%1 = cir.ternary (%arg0, true {
%2 = cir.const #cir.int<42> : !s32i
cir.yield %2 : !s32i
@@ -63,7 +63,7 @@ module {
}
// CHECK: cir.func{{.*}} @non_simplifiable_ternary(%[[ARG0:.+]]: !cir.bool) -> !s32i {
- // CHECK-NEXT: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
+ // CHECK-NEXT: %[[#A:]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[#B:]] = cir.ternary(%[[ARG0]], true {
// CHECK-NEXT: %[[#C:]] = cir.const #cir.int<42> : !s32i
// CHECK-NEXT: cir.yield %[[#C]] : !s32i
diff --git a/clang/test/CIR/Transforms/ternary.cir b/clang/test/CIR/Transforms/ternary.cir
index 4120e4e992c32..20a5c9edb476a 100644
--- a/clang/test/CIR/Transforms/ternary.cir
+++ b/clang/test/CIR/Transforms/ternary.cir
@@ -4,8 +4,8 @@
module {
cir.func @foo(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
- %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+ %0 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
%2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
%3 = cir.const #cir.int<0> : !s32i
@@ -23,8 +23,8 @@ module {
}
// CHECK: cir.func{{.*}} @foo(%arg0: !s32i) -> !s32i {
-// CHECK: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["y", init] {alignment = 4 : i64}
-// CHECK: %1 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+// CHECK: %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
// CHECK: %3 = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/Transforms/vector-extract-fold.cir b/clang/test/CIR/Transforms/vector-extract-fold.cir
index 5d0dffccc91f4..8f88c332ff1bd 100644
--- a/clang/test/CIR/Transforms/vector-extract-fold.cir
+++ b/clang/test/CIR/Transforms/vector-extract-fold.cir
@@ -4,7 +4,7 @@
module {
cir.func @fold_extract_vector_op_test() {
- %init = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init] {alignment = 4 : i64}
+ %init = cir.alloca "e" align(4) init !s32i -> !cir.ptr<!s32i>
%const_vec = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
%index = cir.const #cir.int<1> : !s32i
%ele = cir.vec.extract %const_vec[%index : !s32i] : !cir.vector<4 x !s32i>
@@ -12,12 +12,12 @@ module {
cir.return
}
- // CHECK: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+ // CHECK: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[VALUE:.*]] = cir.const #cir.int<2> : !s32i
// CHECK: cir.store %[[VALUE]], %[[INIT]] : !s32i, !cir.ptr<!s32i>
cir.func @fold_extract_vector_op_index_out_of_bounds_test() {
- %init = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init] {alignment = 4 : i64}
+ %init = cir.alloca "e" align(4) init !s32i -> !cir.ptr<!s32i>
%const_vec = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
%index = cir.const #cir.int<9> : !s32i
%ele = cir.vec.extract %const_vec[%index : !s32i] : !cir.vector<4 x !s32i>
@@ -25,7 +25,7 @@ module {
cir.return
}
- // CHECK: %[[INIT:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e", init]
+ // CHECK: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CHECK: %[[CONST_VEC:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK: %[[INDEX:.*]] = cir.const #cir.int<9> : !s32i
// CHECK: %[[ELE:.*]] = cir.vec.extract %[[CONST_VEC]][%[[INDEX]] : !s32i] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/func-simple.cpp b/clang/test/CIR/func-simple.cpp
index 54cc90539b6eb..3a32703bd4c58 100644
--- a/clang/test/CIR/func-simple.cpp
+++ b/clang/test/CIR/func-simple.cpp
@@ -13,7 +13,7 @@ void voidret() { return; }
int intfunc() { return 42; }
// CHECK: cir.func{{.*}} @_Z7intfuncv() -> (!s32i {llvm.noundef})
-// CHECK: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: %1 = cir.const #cir.int<42> : !s32i
// CHECK: cir.store %1, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -28,7 +28,7 @@ int scopes() {
}
}
// CHECK: cir.func{{.*}} @_Z6scopesv() -> (!s32i {llvm.noundef})
-// CHECK: %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
// CHECK: cir.scope {
// CHECK: cir.scope {
// CHECK: %1 = cir.const #cir.int<99> : !s32i
@@ -42,7 +42,7 @@ int scopes() {
long longfunc() { return 42l; }
// CHECK: cir.func{{.*}} @_Z8longfuncv() -> (!s64i {llvm.noundef})
-// CHECK: %0 = cir.alloca !s64i, !cir.ptr<!s64i>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(8) !s64i -> !cir.ptr<!s64i>
// CHECK: %1 = cir.const #cir.int<42> : !s64i
// CHECK: cir.store %1, %0 : !s64i, !cir.ptr<!s64i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!s64i>, !s64i
@@ -51,7 +51,7 @@ long longfunc() { return 42l; }
unsigned unsignedfunc() { return 42u; }
// CHECK: cir.func{{.*}} @_Z12unsignedfuncv() -> (!u32i {llvm.noundef})
-// CHECK: %0 = cir.alloca !u32i, !cir.ptr<!u32i>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(4) !u32i -> !cir.ptr<!u32i>
// CHECK: %1 = cir.const #cir.int<42> : !u32i
// CHECK: cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!u32i>, !u32i
@@ -60,7 +60,7 @@ unsigned unsignedfunc() { return 42u; }
unsigned long long ullfunc() { return 42ull; }
// CHECK: cir.func{{.*}} @_Z7ullfuncv() -> (!u64i {llvm.noundef})
-// CHECK: %0 = cir.alloca !u64i, !cir.ptr<!u64i>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(8) !u64i -> !cir.ptr<!u64i>
// CHECK: %1 = cir.const #cir.int<42> : !u64i
// CHECK: cir.store %1, %0 : !u64i, !cir.ptr<!u64i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!u64i>, !u64i
@@ -69,7 +69,7 @@ unsigned long long ullfunc() { return 42ull; }
bool boolfunc() { return true; }
// CHECK: cir.func{{.*}} @_Z8boolfuncv() -> (!cir.bool {llvm.noundef})
-// CHECK: %0 = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["__retval"] {alignment = 1 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(1) !cir.bool -> !cir.ptr<!cir.bool>
// CHECK: %1 = cir.const #true
// CHECK: cir.store %1, %0 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
@@ -78,7 +78,7 @@ bool boolfunc() { return true; }
float floatfunc() { return 42.42f; }
// CHECK: cir.func{{.*}} @_Z9floatfuncv() -> (!cir.float {llvm.noundef})
-// CHECK: %0 = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["__retval"] {alignment = 4 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(4) !cir.float -> !cir.ptr<!cir.float>
// CHECK: %1 = cir.const #cir.fp<4.242
// CHECK: cir.store %1, %0 : !cir.float, !cir.ptr<!cir.float>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
@@ -87,7 +87,7 @@ float floatfunc() { return 42.42f; }
double doublefunc() { return 42.42; }
// CHECK: cir.func{{.*}} @_Z10doublefuncv() -> (!cir.double {llvm.noundef})
-// CHECK: %0 = cir.alloca !cir.double, !cir.ptr<!cir.double>, ["__retval"] {alignment = 8 : i64}
+// CHECK: %0 = cir.alloca "__retval" align(8) !cir.double -> !cir.ptr<!cir.double>
// CHECK: %1 = cir.const #cir.fp<4.242
// CHECK: cir.store %1, %0 : !cir.double, !cir.ptr<!cir.double>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.double>, !cir.double
>From 902db26586990b23feac6bce8e0a884b6e4083c5 Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Wed, 27 May 2026 20:11:37 -0500
Subject: [PATCH 3/7] fix after rebase
---
.../amdgpu-stack-alloca-array-decay.cpp | 4 +--
clang/test/CIR/CodeGen/atomic.c | 8 +++---
clang/test/CIR/CodeGen/call.c | 2 +-
clang/test/CIR/CodeGen/call.cpp | 2 +-
.../cleanup-conditional-with-wrapper-eh.cpp | 26 +++++++++----------
.../cleanup-conditional-with-wrapper.cpp | 26 +++++++++----------
.../test/CIR/CodeGen/new-array-in-ternary.cpp | 8 +++---
clang/test/CIR/CodeGen/vla-pointer-arith.c | 6 ++---
clang/test/CIR/CodeGenOpenCL/vector.cl | 16 ++++++------
9 files changed, 49 insertions(+), 49 deletions(-)
diff --git a/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp b/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp
index 725a78016e50e..53a4ee3b8ef85 100644
--- a/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp
+++ b/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp
@@ -18,8 +18,8 @@ void foo() {
}
// CIR-LABEL: cir.func{{.*}} @_Z3foov()
-// CIR: %[[FMT_RAW:.*]] = cir.alloca !cir.array<!s8i x 6>, !cir.ptr<!cir.array<!s8i x 6>, target_address_space(5)>, ["fmt"
-// CIR-NEXT: %[[TMP_RAW:.*]] = cir.alloca !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>, target_address_space(5)>, ["tmp"
+// CIR: %[[FMT_RAW:.*]] = cir.alloca "fmt" {{.*}} !cir.array<!s8i x 6> -> !cir.ptr<!cir.array<!s8i x 6>, target_address_space(5)>
+// CIR-NEXT: %[[TMP_RAW:.*]] = cir.alloca "tmp" {{.*}} !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>, target_address_space(5)>
// CIR-DAG: %[[FMT:.*]] = cir.cast address_space %[[FMT_RAW]] : !cir.ptr<!cir.array<!s8i x 6>, target_address_space(5)> -> !cir.ptr<!cir.array<!s8i x 6>>
// CIR-DAG: %[[TMP:.*]] = cir.cast address_space %[[TMP_RAW]] : !cir.ptr<!cir.ptr<!s8i>, target_address_space(5)> -> !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[FMT]] : !cir.ptr<!cir.array<!s8i x 6>> -> !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/atomic.c b/clang/test/CIR/CodeGen/atomic.c
index 7c6bb5490d64b..f3190c248a0d2 100644
--- a/clang/test/CIR/CodeGen/atomic.c
+++ b/clang/test/CIR/CodeGen/atomic.c
@@ -956,8 +956,8 @@ float *atomic_fetch_ptr_to_ptr(float **ptr, int value) {
// OGCG-LABEL: @atomic_fetch_ptr_to_ptr
return __atomic_fetch_add(ptr, value, __ATOMIC_SEQ_CST);
- // CIR: %[[PTR:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>, ["ptr", init]
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["atomic-temp"] {alignment = 8 : i64}
+ // CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!cir.float> -> !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_LOAD:.*]] = cir.load align(8) %[[PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>, !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_CAST:.*]] = cir.cast bitcast %[[PTR_LOAD]] : !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!s64i>
// CIR: %[[RESULT:.*]] = cir.atomic.fetch add seq_cst syncscope(system) fetch_first %[[PTR_CAST]], %{{.*}} : (!cir.ptr<!s64i>, !s64i) -> !s64i
@@ -976,8 +976,8 @@ float *atomic_fetch_ptr_to_ptr2(float **ptr, int value) {
// LLVM-LABEL: @atomic_fetch_ptr_to_ptr2
// OGCG-LABEL: @atomic_fetch_ptr_to_ptr2
return __atomic_add_fetch(ptr, value, __ATOMIC_SEQ_CST);
- // CIR: %[[PTR:.*]] = cir.alloca !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>, ["ptr", init]
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["atomic-temp"] {alignment = 8 : i64}
+ // CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!cir.float> -> !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_LOAD:.*]] = cir.load align(8) %[[PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>, !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_CAST:.*]] = cir.cast bitcast %[[PTR_LOAD]] : !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!s64i>
// CIR: %[[RESULT:.*]] = cir.atomic.fetch add seq_cst syncscope(system) %[[PTR_CAST]], %{{.*}} : (!cir.ptr<!s64i>, !s64i) -> !s64i
diff --git a/clang/test/CIR/CodeGen/call.c b/clang/test/CIR/CodeGen/call.c
index 2f837a9f66114..4a3f2f98219d6 100644
--- a/clang/test/CIR/CodeGen/call.c
+++ b/clang/test/CIR/CodeGen/call.c
@@ -135,7 +135,7 @@ void f13(void) {
fp();
}
// CIR-LABEL: cir.func{{.*}} @f13()
-// CIR: %[[FP_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.func<()>>, !cir.ptr<!cir.ptr<!cir.func<()>>>, ["fp"]
+// CIR: %[[FP_ALLOCA:.*]] = cir.alloca "fp" {{.*}} !cir.ptr<!cir.func<()>> -> !cir.ptr<!cir.ptr<!cir.func<()>>>
// CIR: %[[LOAD_FP:.*]] = cir.load align(8) atomic(seq_cst) %[[FP_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.func<()>>>, !cir.ptr<!cir.func<()>>
// CIR: cir.call %[[LOAD_FP]]() : (!cir.ptr<!cir.func<()>>) -> ()
diff --git a/clang/test/CIR/CodeGen/call.cpp b/clang/test/CIR/CodeGen/call.cpp
index 3ec562bacd64e..043fa4c94d1ac 100644
--- a/clang/test/CIR/CodeGen/call.cpp
+++ b/clang/test/CIR/CodeGen/call.cpp
@@ -142,7 +142,7 @@ void use_TakesFunc() {
}
// CIR-LABEL: _Z9TakesFuncIFivEEDcRKT_
-// CIR-NEXT: %[[FUNC_ALLOCA:.*]] = cir.alloca !cir.ptr<!cir.func<() -> !s32i>>, !cir.ptr<!cir.ptr<!cir.func<() -> !s32i>>>, ["f", init, const]
+// CIR-NEXT: %[[FUNC_ALLOCA:.*]] = cir.alloca "f" {{.*}} init const !cir.ptr<!cir.func<() -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<() -> !s32i>>>
// CIR: %[[FUNC_LOAD:.*]] = cir.load %[[FUNC_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.func<() -> !s32i>>>, !cir.ptr<!cir.func<() -> !s32i>>
// CIR-NEXT: %[[CALL:.*]] = cir.call %[[FUNC_LOAD]]() : (!cir.ptr<!cir.func<() -> !s32i>>) -> (!s32i {llvm.noundef})
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
index ae525bbe637ad..942035461ccde 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
@@ -40,9 +40,9 @@ Wrapper makeWrapper() {
}
// CIR: cir.func {{.*}} @_Z11makeWrapperv() -> !rec_Wrapper
-// CIR: %[[RETVAL:.*]] = cir.alloca !rec_Wrapper, !cir.ptr<!rec_Wrapper>, ["__retval"]
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca !rec_std3A3Aunique_ptr3CBase3E, !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>, ["agg.tmp0"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_Wrapper -> !cir.ptr<!rec_Wrapper>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3Aunique_ptr3CBase3E -> !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>
// CIR: cir.cleanup.scope {
// CIR: %[[FLAG:.*]] = cir.load{{.*}} %{{.*}}
// CIR: %[[FALSE:.*]] = cir.const #false
@@ -191,16 +191,16 @@ void APFixedPoint::add(int x) const {
}
// CIR: cir.func {{.*}} @_ZNK12APFixedPoint3addEi(%{{.*}}: !cir.ptr<!rec_APFixedPoint>{{.*}}, %{{.*}}: !s32i{{.*}})
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[THISVAL:.*]] = cir.alloca !rec_APInt, !cir.ptr<!rec_APInt>, ["ThisVal"]
-// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THISVAL:.*]] = cir.alloca "ThisVal" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
+// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X_BOOL:.*]] = cir.cast int_to_bool %[[X]]
// CIR: cir.if %[[X_BOOL]] {
-// CIR: %[[AGG_TMP:.*]] = cir.alloca !rec_APInt, !cir.ptr<!rec_APInt>, ["agg.tmp.ensured"]
+// CIR: %[[AGG_TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
// CIR: cir.cleanup.scope {
// CIR: %[[X2:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X2_BOOL:.*]] = cir.cast int_to_bool %[[X2]]
@@ -357,17 +357,17 @@ void makeEntry() {
}
// CIR: cir.func {{.*}} @_Z9makeEntryv()
-// CIR: %[[REF_TMP:.*]] = cir.alloca !rec_Iter, !cir.ptr<!rec_Iter>, ["ref.tmp0"]
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca !rec_Path, !cir.ptr<!rec_Path>, ["agg.tmp0"]
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Iter -> !cir.ptr<!rec_Iter>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_Path -> !cir.ptr<!rec_Path>
// CIR: cir.cleanup.scope {
// CIR: cir.cleanup.scope {
// CIR: %[[CALL:.*]] = cir.call @_ZN4ItercvbEv(%[[REF_TMP]])
// CIR: cir.if %[[CALL]] {
-// CIR: %[[ENSURED_T:.*]] = cir.alloca !rec_Entry, !cir.ptr<!rec_Entry>, ["agg.tmp.ensured"]
+// CIR: %[[ENSURED_T:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
// CIR: cir.call @_ZN5EntryC1Ev(%[[ENSURED_T]])
// CIR: } else {
-// CIR: %[[ENSURED_F:.*]] = cir.alloca !rec_Entry, !cir.ptr<!rec_Entry>, ["agg.tmp.ensured"]
+// CIR: %[[ENSURED_F:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
// CIR: %{{.*}} = cir.get_global @g_path
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
index cc3c595387e48..66a40d118b3ca 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
@@ -40,9 +40,9 @@ Wrapper makeWrapper() {
}
// CIR: cir.func {{.*}} @_Z11makeWrapperv() -> !rec_Wrapper
-// CIR: %[[RETVAL:.*]] = cir.alloca !rec_Wrapper, !cir.ptr<!rec_Wrapper>, ["__retval"]
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca !rec_std3A3Aunique_ptr3CBase3E, !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>, ["agg.tmp0"]
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_Wrapper -> !cir.ptr<!rec_Wrapper>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3Aunique_ptr3CBase3E -> !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>
// CIR: cir.cleanup.scope {
// CIR: %[[FLAG:.*]] = cir.load{{.*}} %{{.*}}
// CIR: %[[FALSE:.*]] = cir.const #false
@@ -144,16 +144,16 @@ void APFixedPoint::add(int x) const {
}
// CIR: cir.func {{.*}} @_ZNK12APFixedPoint3addEi(%{{.*}}: !cir.ptr<!rec_APFixedPoint>{{.*}}, %{{.*}}: !s32i{{.*}})
-// CIR: %[[X_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init]
-// CIR: %[[THISVAL:.*]] = cir.alloca !rec_APInt, !cir.ptr<!rec_APInt>, ["ThisVal"]
-// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THISVAL:.*]] = cir.alloca "ThisVal" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
+// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X_BOOL:.*]] = cir.cast int_to_bool %[[X]]
// CIR: cir.if %[[X_BOOL]] {
-// CIR: %[[AGG_TMP:.*]] = cir.alloca !rec_APInt, !cir.ptr<!rec_APInt>, ["agg.tmp.ensured"]
+// CIR: %[[AGG_TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
// CIR: cir.cleanup.scope {
// CIR: %[[X2:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X2_BOOL:.*]] = cir.cast int_to_bool %[[X2]]
@@ -278,17 +278,17 @@ void makeEntry() {
}
// CIR: cir.func {{.*}} @_Z9makeEntryv()
-// CIR: %[[REF_TMP:.*]] = cir.alloca !rec_Iter, !cir.ptr<!rec_Iter>, ["ref.tmp0"]
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca !rec_Path, !cir.ptr<!rec_Path>, ["agg.tmp0"]
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Iter -> !cir.ptr<!rec_Iter>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_Path -> !cir.ptr<!rec_Path>
// CIR: cir.cleanup.scope {
// CIR: cir.cleanup.scope {
// CIR: %[[CALL:.*]] = cir.call @_ZN4ItercvbEv(%[[REF_TMP]])
// CIR: cir.if %[[CALL]] {
-// CIR: %[[ENSURED_T:.*]] = cir.alloca !rec_Entry, !cir.ptr<!rec_Entry>, ["agg.tmp.ensured"]
+// CIR: %[[ENSURED_T:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
// CIR: cir.call @_ZN5EntryC1Ev(%[[ENSURED_T]])
// CIR: } else {
-// CIR: %[[ENSURED_F:.*]] = cir.alloca !rec_Entry, !cir.ptr<!rec_Entry>, ["agg.tmp.ensured"]
+// CIR: %[[ENSURED_F:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
// CIR: %{{.*}} = cir.get_global @g_path
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]]
diff --git a/clang/test/CIR/CodeGen/new-array-in-ternary.cpp b/clang/test/CIR/CodeGen/new-array-in-ternary.cpp
index 4b6507f31b6f2..0a53f2f6f3e85 100644
--- a/clang/test/CIR/CodeGen/new-array-in-ternary.cpp
+++ b/clang/test/CIR/CodeGen/new-array-in-ternary.cpp
@@ -51,12 +51,12 @@ DoubleAPFloat::DoubleAPFloat()
// LLVM: ret void
// CIR-EH-LABEL: cir.func {{.*}} @_ZN13DoubleAPFloatC2Ev
-// CIR-EH: %[[ACTIVE:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
+// CIR-EH: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR-EH: %[[FALSE_INIT:.*]] = cir.const #false
// CIR-EH: cir.store %[[FALSE_INIT]], %[[ACTIVE]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR-EH: %[[RESULT:.*]] = cir.ternary({{.*}}, true {
-// CIR-EH: %[[NEW_RESULT:.*]] = cir.alloca !cir.ptr<!rec_APFloat>, !cir.ptr<!cir.ptr<!rec_APFloat>>, ["__new_result"]
-// CIR-EH: %[[SPILL:.*]] = cir.alloca !cir.ptr<!rec_APFloat>, !cir.ptr<!cir.ptr<!rec_APFloat>>, ["tmp.exprcleanup"]
+// CIR-EH: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_APFloat> -> !cir.ptr<!cir.ptr<!rec_APFloat>>
+// CIR-EH: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.ptr<!rec_APFloat> -> !cir.ptr<!cir.ptr<!rec_APFloat>>
// CIR-EH: cir.call @_Znam
// CIR-EH: cir.cleanup.scope {
// CIR-EH: %[[TRUE:.*]] = cir.const #true
@@ -138,7 +138,7 @@ T &pickRef(bool b) {
// CIR-EH-LABEL: cir.func {{.*}} @_Z7pickRefb
// CIR-EH: %[[RES:.*]] = cir.ternary({{.*}}, true {
-// CIR-EH: %[[SPILL:.*]] = cir.alloca !cir.ptr<!rec_T>, !cir.ptr<!cir.ptr<!rec_T>>, ["tmp.exprcleanup"]
+// CIR-EH: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.ptr<!rec_T> -> !cir.ptr<!cir.ptr<!rec_T>>
// CIR-EH: cir.call @_Znam
// CIR-EH: cir.cleanup.scope {
// CIR-EH: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/vla-pointer-arith.c b/clang/test/CIR/CodeGen/vla-pointer-arith.c
index 89c7083924002..4ebe189d93462 100644
--- a/clang/test/CIR/CodeGen/vla-pointer-arith.c
+++ b/clang/test/CIR/CodeGen/vla-pointer-arith.c
@@ -14,7 +14,7 @@ void test_vla_ptr_add(int n, int i) {
}
// CIR-LABEL: @test_vla_ptr_add
-// CIR: cir.alloca {{.*}} ["arr"]
+// CIR: cir.alloca "arr" {{.*}}
// CIR: %[[N2:.*]] = cir.load{{.*}} !cir.ptr<!s32i>, !s32i
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N2]] : !s32i -> !u64i
// CIR: %[[P:.*]] = cir.load{{.*}} !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -38,7 +38,7 @@ void test_vla_ptr_inc(int n) {
}
// CIR-LABEL: @test_vla_ptr_inc
-// CIR: cir.alloca {{.*}} ["arr"]
+// CIR: cir.alloca "arr" {{.*}}
// CIR: %[[N2:.*]] = cir.load{{.*}} !cir.ptr<!s32i>, !s32i
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N2]] : !s32i -> !u64i
// CIR: %[[P:.*]] = cir.load{{.*}} !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -57,7 +57,7 @@ void test_vla_ptr_dec(int n) {
}
// CIR-LABEL: @test_vla_ptr_dec
-// CIR: cir.alloca {{.*}} ["arr"]
+// CIR: cir.alloca "arr" {{.*}}
// CIR: %[[N2:.*]] = cir.load{{.*}} !cir.ptr<!s32i>, !s32i
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N2]] : !s32i -> !u64i
// CIR: %[[P:.*]] = cir.load{{.*}} !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenCL/vector.cl b/clang/test/CIR/CodeGenOpenCL/vector.cl
index 34183fcffabf8..988dd07ee9877 100644
--- a/clang/test/CIR/CodeGenOpenCL/vector.cl
+++ b/clang/test/CIR/CodeGenOpenCL/vector.cl
@@ -14,10 +14,10 @@ int4 vec_ternary(int4 c, int4 a, int4 b) {
return c ? a : c;
}
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["b", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["__retval"]
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -44,10 +44,10 @@ float4 vec_ternary_f4(int4 c, float4 a, float4 b) {
return c ? a : b;
}
-// CIR: %[[C_ADDR:.*]] = cir.alloca !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>, ["c", init]
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["a", init]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["b", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>, ["__retval"]
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %{{.*}}, %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %{{.*}}, %[[B_ADDR]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
>From 17c064ff46821b775a90ed778c1cb1176b78eb01 Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Wed, 27 May 2026 20:36:16 -0500
Subject: [PATCH 4/7] apply review
---
clang/test/CIR/CodeGen/agg-expr-lvalue.c | 14 ++++----
.../CIR/CodeGen/cleanup-conditional-eh.cpp | 2 +-
.../test/CIR/CodeGen/cleanup-conditional.cpp | 2 +-
clang/test/CIR/CodeGen/coro-task.cpp | 36 +++++++++----------
.../CIR/CodeGen/cxx-conversion-operators.cpp | 4 +--
clang/test/CIR/CodeGen/cxx-default-init.cpp | 4 +--
.../CodeGen/delete-array-throwing-dtor.cpp | 2 +-
clang/test/CIR/CodeGen/forrange.cpp | 8 ++---
clang/test/CIR/CodeGen/lambda-dtor-field.cpp | 10 +++---
.../lambda-static-invoker-agg-return.cpp | 2 +-
.../CIR/CodeGen/lambda-static-invoker.cpp | 4 +--
clang/test/CIR/CodeGen/loop.cpp | 2 +-
.../CIR/CodeGen/pointer-to-data-member.cpp | 8 ++---
clang/test/CIR/CodeGen/vla-pointer-arith.c | 6 ++--
.../test/CIR/CodeGenOpenACC/declare-copy.cpp | 4 +--
.../CIR/CodeGenOpenACC/declare-deviceptr.cpp | 2 +-
clang/test/CIR/CodeGenOpenMP/parallel.c | 4 +--
.../flatten-cleanup-scope-simple.cir | 4 +--
18 files changed, 59 insertions(+), 59 deletions(-)
diff --git a/clang/test/CIR/CodeGen/agg-expr-lvalue.c b/clang/test/CIR/CodeGen/agg-expr-lvalue.c
index 5e5639f8f32af..43beff4f16ad4 100644
--- a/clang/test/CIR/CodeGen/agg-expr-lvalue.c
+++ b/clang/test/CIR/CodeGen/agg-expr-lvalue.c
@@ -27,8 +27,8 @@ void test_member_in_array(void) {
// LLVM-DAG: @[[MATRIX_CONST:.*]] = private constant [2 x [6 x i8]] {{.*}}
// CIR-LABEL: cir.func{{.*}} @test_member_in_array
-// CIR: %[[LINE:.*]] = cir.alloca "line" {{.*}} init !rec_Line{{.*}}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>{{.*}}
+// CIR: %[[LINE:.*]] = cir.alloca "line" {{.*}} init !rec_Line
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>
// CIR: cir.get_global @[[LINE_CONST]]
// CIR: cir.copy
// CIR: %[[MEMBER:.*]] = cir.get_member %[[LINE]][0] {name = "start"}
@@ -55,8 +55,8 @@ void test_member_arrow_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_member_arrow_in_array
-// CIR: %[[PTR:.*]] = cir.alloca "line_ptr" {{.*}} !cir.ptr<!rec_Line>{{.*}}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>{{.*}}
+// CIR: %[[PTR:.*]] = cir.alloca "line_ptr" {{.*}} !cir.ptr<!rec_Line>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>
// CIR: %[[LOADED:.*]] = cir.load{{.*}}%[[PTR]]
// CIR: %[[MEMBER:.*]] = cir.get_member %[[LOADED]][0] {name = "start"}
// CIR: cir.copy
@@ -82,8 +82,8 @@ void test_deref_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_deref_in_array
-// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} !cir.ptr<!rec_Point>{{.*}}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>{{.*}}
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} !cir.ptr<!rec_Point>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>
// CIR: %[[LOADED:.*]] = cir.load{{.*}}%[[PTR]]
// CIR: cir.copy
@@ -105,7 +105,7 @@ void test_string_array_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_string_array_in_array
-// CIR: %[[MATRIX:.*]] = cir.alloca "matrix" {{.*}} init !cir.array<!cir.array<!s8i x 6> x 2> -> {{.*}}
+// CIR: %[[MATRIX:.*]] = cir.alloca "matrix" {{.*}} init !cir.array<!cir.array<!s8i x 6> x 2>
// CIR: %[[CONST:.*]] = cir.get_global @[[MATRIX_CONST]] : !cir.ptr<!cir.array<!cir.array<!s8i x 6> x 2>>
// CIR: cir.copy %[[CONST]] to %[[MATRIX]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
index a870ea8481965..473a14f8a7aba 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
@@ -429,7 +429,7 @@ int test_false_positive_conditional(bool c) {
return S().get() ? 1 : 2;
}
// CIR-LABEL: @_Z31test_false_positive_conditionalb
-// CIR-NOT: cir.alloca "cleanup.cond" {{.*}}
+// CIR-NOT: cir.alloca "cleanup.cond"
// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev(%[[TMP]])
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional.cpp b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
index 15b0170aa63c2..2d11d9849eeaa 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
@@ -365,7 +365,7 @@ int test_false_positive_conditional(bool c) {
return S().get() ? 1 : 2;
}
// No cleanup.cond alloca — the destructor is unconditional.
-// CIR-NOT: cir.alloca "cleanup.cond" {{.*}}
+// CIR-NOT: cir.alloca "cleanup.cond"
// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev(%[[TMP]])
// The cleanup scope wraps the get() + select + store.
diff --git a/clang/test/CIR/CodeGen/coro-task.cpp b/clang/test/CIR/CodeGen/coro-task.cpp
index 7abaabedd4a27..d0c2fcae61e58 100644
--- a/clang/test/CIR/CodeGen/coro-task.cpp
+++ b/clang/test/CIR/CodeGen/coro-task.cpp
@@ -150,9 +150,9 @@ VoidTask silly_task() {
}
// CIR: cir.func coroutine {{.*}} @_Z10silly_taskv() -> ![[VoidTask]]
-// CIR: %[[VoidTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]] -> {{.*}}
+// CIR: %[[VoidTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]]
// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[VoidPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]] -> {{.*}}
+// CIR: %[[VoidPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]]
// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]]
@@ -351,11 +351,11 @@ folly::coro::Task<int> byRef(const std::string& s) {
}
// CIR: cir.func coroutine {{.*}} @_Z5byRefRKSt6string(%[[ARG:.*]]: !cir.ptr<![[StdString]]> {{.*}}) -> ![[IntTask]]
-// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]> -> {{.*}}
-// CIR: %[[IntTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[IntTask]] -> {{.*}}
+// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]>
+// CIR: %[[IntTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[IntTask]]
// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[AllocaFnUse:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]> -> {{.*}}
-// CIR: %[[IntPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[IntPromisse]] -> {{.*}}
+// CIR: %[[AllocaFnUse:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]>
+// CIR: %[[IntPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[IntPromisse]]
// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseInt]]
@@ -444,18 +444,18 @@ folly::coro::Task<void> yield1() {
// Prologue allocas (still present in output)
// CIR-DAG: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]]
// CIR-DAG: %[[FRAME:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR-DAG: %[[PROMISE:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]] -> {{.*}}
-// CIR-DAG: %[[SUSP0:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]] -> {{.*}}
-// CIR-DAG: %[[CH_VOID0:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]] -> {{.*}}
-// CIR-DAG: %[[CH_PROM0:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]] -> {{.*}}
-// CIR-DAG: %[[T_ADDR:.*]] = cir.alloca "t" {{.*}} init ![[VoidTask]] -> {{.*}}
-// CIR-DAG: %[[SUSP1:.*]] = cir.alloca "ref.tmp1" {{.*}} ![[SuspendAlways]] -> {{.*}}
-// CIR-DAG: %[[AWAITER_COPY_ADDR:.*]] = cir.alloca "agg.tmp2" {{.*}} ![[VoidTask]] -> {{.*}}
-// CIR-DAG: %[[CH_VOID1:.*]] = cir.alloca "agg.tmp3" {{.*}} ![[CoroHandleVoid]] -> {{.*}}
-// CIR-DAG: %[[CH_PROM1:.*]] = cir.alloca "agg.tmp4" {{.*}} ![[CoroHandlePromiseVoid]] -> {{.*}}
-// CIR-DAG: %[[SUSP2:.*]] = cir.alloca "ref.tmp2" {{.*}} ![[SuspendAlways]] -> {{.*}}
-// CIR-DAG: %[[CH_VOID2:.*]] = cir.alloca "agg.tmp5" {{.*}} ![[CoroHandleVoid]] -> {{.*}}
-// CIR-DAG: %[[CH_PROM2:.*]] = cir.alloca "agg.tmp6" {{.*}} ![[CoroHandlePromiseVoid]] -> {{.*}}
+// CIR-DAG: %[[PROMISE:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]]
+// CIR-DAG: %[[SUSP0:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
+// CIR-DAG: %[[CH_VOID0:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
+// CIR-DAG: %[[CH_PROM0:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]]
+// CIR-DAG: %[[T_ADDR:.*]] = cir.alloca "t" {{.*}} init ![[VoidTask]]
+// CIR-DAG: %[[SUSP1:.*]] = cir.alloca "ref.tmp1" {{.*}} ![[SuspendAlways]]
+// CIR-DAG: %[[AWAITER_COPY_ADDR:.*]] = cir.alloca "agg.tmp2" {{.*}} ![[VoidTask]]
+// CIR-DAG: %[[CH_VOID1:.*]] = cir.alloca "agg.tmp3" {{.*}} ![[CoroHandleVoid]]
+// CIR-DAG: %[[CH_PROM1:.*]] = cir.alloca "agg.tmp4" {{.*}} ![[CoroHandlePromiseVoid]]
+// CIR-DAG: %[[SUSP2:.*]] = cir.alloca "ref.tmp2" {{.*}} ![[SuspendAlways]]
+// CIR-DAG: %[[CH_VOID2:.*]] = cir.alloca "agg.tmp5" {{.*}} ![[CoroHandleVoid]]
+// CIR-DAG: %[[CH_PROM2:.*]] = cir.alloca "agg.tmp6" {{.*}} ![[CoroHandlePromiseVoid]]
// CIR: cir.cleanup.scope {
// initial_suspend + await(init)
diff --git a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
index afe147eda9199..a80256fb2be0e 100644
--- a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
+++ b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
@@ -51,8 +51,8 @@ void test() {
// CIR: cir.func {{.*}} @_Z4testv()
// CIR: %[[X_ALLOCA:.+]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[I_ALLOCA:.+]] = cir.alloca "i" {{.*}} {{.*}} -> {{.*}}
-// CIR: %[[O_ALLOCA:.+]] = cir.alloca "o" {{.*}} {{.*}} -> {{.*}}
+// CIR: %[[I_ALLOCA:.+]] = cir.alloca "i" {{.*}}
+// CIR: %[[O_ALLOCA:.+]] = cir.alloca "o" {{.*}}
// CIR: %[[CONST_42:.+]] = cir.const #cir.int<42> : !s32i
// CIR: cir.store align(4) %[[CONST_42]], %[[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[INLINE_CALL:.+]] = cir.call @_ZNK15inline_operatorcviEv(%[[I_ALLOCA]]) : ({{.*}}) -> (!s32i{{.*}})
diff --git a/clang/test/CIR/CodeGen/cxx-default-init.cpp b/clang/test/CIR/CodeGen/cxx-default-init.cpp
index 5d96ef8be84c9..3aa852111151d 100644
--- a/clang/test/CIR/CodeGen/cxx-default-init.cpp
+++ b/clang/test/CIR/CodeGen/cxx-default-init.cpp
@@ -20,7 +20,7 @@ struct ZeroInit {
};
// CIR: cir.func{{.*}} @_ZN8ZeroInitC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_ZeroInit> {{.*}})
-// CIR: %[[ITER:.*]] = cir.alloca "arrayinit.temp" {{.*}}
+// CIR: %[[ITER:.*]] = cir.alloca "arrayinit.temp"
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA:.*]]
// CIR: %[[I:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -126,7 +126,7 @@ struct ValueInit {
};
// CIR: cir.func{{.*}} @_ZN9ValueInitC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_ValueInit> {{.*}})
-// CIR: %[[ITER:.*]] = cir.alloca "arrayinit.temp" {{.*}}
+// CIR: %[[ITER:.*]] = cir.alloca "arrayinit.temp"
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA:.*]]
// CIR: %[[I:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
diff --git a/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp b/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
index 1d85fd6ad01ab..090617bd34375 100644
--- a/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
+++ b/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
@@ -58,7 +58,7 @@ void test_delete_array_throwing_dtor(ThrowingDtor *ptr) {
// CIR: %[[END:.*]] = cir.ptr_stride %[[PTR]], %[[NUM_ELEM]]
// CIR: %[[NOT_EMPTY:.*]] = cir.cmp ne %[[END]], %[[PTR]]
// CIR: cir.if %[[NOT_EMPTY]] {
-// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" {{.*}}
+// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx"
// CIR: cir.store %[[END]], %[[ARR_IDX]]
//
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/forrange.cpp b/clang/test/CIR/CodeGen/forrange.cpp
index cb32fb1dd6bf4..c8534d7555628 100644
--- a/clang/test/CIR/CodeGen/forrange.cpp
+++ b/clang/test/CIR/CodeGen/forrange.cpp
@@ -115,8 +115,8 @@ void for_range3() {
// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C3
// CIR: cir.scope {
// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C3>
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
-// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: cir.for : cond {
@@ -144,8 +144,8 @@ void for_range4() {
// CIR: cir.func{{.*}} @_Z10for_range4v()
// CIR: cir.scope {
// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C3>
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
-// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>{{.*}}
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
// CIR: %[[HD:.*]] = cir.alloca "hd" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
diff --git a/clang/test/CIR/CodeGen/lambda-dtor-field.cpp b/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
index 73b4ea3421ca7..a82cfa8847941 100644
--- a/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
+++ b/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
@@ -18,7 +18,7 @@ void capture_one(S s) {
}
// CIR-LABEL: @_Z11capture_one1S
-// CIR: %[[LAM:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
+// CIR: %[[LAM:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
// CIR: %[[FIELD:.*]] = cir.get_member %[[LAM]][0] {name = "s"}
// CIR: cir.call @_ZN1SC1ERKS_(%[[FIELD]],
// CIR: cir.cleanup.scope {
@@ -54,7 +54,7 @@ void capture_two(S a, S b) {
}
// CIR-LABEL: @_Z11capture_two1SS_
-// CIR: %[[LAM2:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
+// CIR: %[[LAM2:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
// CIR: %[[FA:.*]] = cir.get_member %[[LAM2]][0] {name = "a"}
// CIR: cir.call @_ZN1SC1ERKS_(%[[FA]],
// CIR: cir.cleanup.scope {
@@ -107,7 +107,7 @@ void capture_mixed(int n, S s) {
}
// CIR-LABEL: @_Z13capture_mixedi1S
-// CIR: %[[LAM3:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
+// CIR: %[[LAM3:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
// CIR: %[[FN:.*]] = cir.get_member %[[LAM3]][0] {name = "n"}
// CIR: cir.load
// CIR: cir.store
@@ -155,7 +155,7 @@ void capture_local() {
// CIR-LABEL: @_Z13capture_localv
// CIR: %[[S4:.*]] = cir.alloca "s" {{.*}} init !rec_S
-// CIR: %[[LAM4:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
+// CIR: %[[LAM4:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
// CIR: cir.call @_ZN1SC1Ev(%[[S4]])
// CIR: cir.cleanup.scope {
// CIR: %[[FL:.*]] = cir.get_member %[[LAM4]][0] {name = "s"}
@@ -214,7 +214,7 @@ void stmt_expr_return(bool cond) {
}
// CIR-LABEL: @_Z16stmt_expr_returnb
-// CIR: %[[LAM5:.*]] = cir.alloca "lam" {{.*}} init !rec_anon{{.*}}
+// CIR: %[[LAM5:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
// CIR: %[[FA5:.*]] = cir.get_member %[[LAM5]][0] {name = "a"}
// CIR: cir.call @_ZN1SC1Ei(%[[FA5]],
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
index 91b90529be165..d9ff90b6f9fce 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
@@ -23,7 +23,7 @@ S agg_invoker() {
// CIR-SAME: (%[[I_ARG:.*]]: !s32i {{.*}}) -> !rec_S
// CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[UNUSED:.*]] = cir.alloca "unused.capture" {{.*}} !rec_anon{{[^,]*}}
+// CIR: %[[UNUSED:.*]] = cir.alloca "unused.capture" {{.*}} !rec_anon
// CIR-NOT: cir.alloca {{.*}} ["agg.tmp
// CIR: cir.store %[[I_ARG]], %[[I_ALLOCA]]
// CIR: %[[I:.*]] = cir.load{{.*}} %[[I_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
index 0cd6f31d31d9f..80f8a7873e509 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
@@ -40,7 +40,7 @@ int g3() {
// CIR: cir.func no_inline lambda internal private dso_local @_ZZ2g3vENK3$_0clERKi(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G3:.*]]> {{.*}}, %[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}})
// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G3]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}}
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval"
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: cir.store %[[REF_I_ARG]], %[[REF_I_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
@@ -68,7 +68,7 @@ int g3() {
// lambda invoker
// CIR: cir.func no_inline internal private dso_local @_ZZ2g3vEN3$_08__invokeERKi(%[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}}) -> (!s32i{{.*}}) {{.*}} {
// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}}
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval"
// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "unused.capture" {{.*}} ![[REC_LAM_G3]] -> !cir.ptr<![[REC_LAM_G3]]>
// CIR: cir.store %[[REF_I_ARG]], %[[REF_I_ALLOCA]]
// CIR: %[[REF_I:.*]] = cir.load{{.*}} %[[REF_I_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp
index 58328dc4b977d..37f6c2962c652 100644
--- a/clang/test/CIR/CodeGen/loop.cpp
+++ b/clang/test/CIR/CodeGen/loop.cpp
@@ -200,7 +200,7 @@ void l4() {
}
// CIR: cir.func{{.*}} @_Z2l4v
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}}
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a"
// CIR: cir.scope {
// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const
// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
index 7f4ce69868166..2a7e822b28897 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
@@ -89,7 +89,7 @@ int test2(const Point &pt, int Point::*member) {
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Point>
// CIR-BEFORE: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init const
// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval"
// CIR-BEFORE: cir.store %[[PT_ARG]], %[[PT_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[PT:.*]] = cir.load %[[PT_ADDR]]
@@ -152,7 +152,7 @@ int test3(const Point *pt, int Point::*member) {
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Point>
// CIR-BEFORE: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init
// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval"
// CIR-BEFORE: cir.store %[[PT_ARG]], %[[PT_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[PT:.*]] = cir.load{{.*}} %[[PT_ADDR]]
@@ -215,7 +215,7 @@ auto test4(int Incomplete::*member) -> int Incomplete::* {
// CIR-BEFORE: cir.func {{.*}} @_Z5test4M10Incompletei(
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Incomplete>
// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval"
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[MEMBER:.*]] = cir.load{{.*}} %[[MEMBER_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER]], %[[RETVAL_ADDR]]
@@ -256,7 +256,7 @@ int test5(Incomplete *ic, int Incomplete::*member) {
// CIR-BEFORE-SAME: %[[MEMBER_ARG:.*]]: !cir.data_member<!s32i in !rec_Incomplete>
// CIR-BEFORE: %[[IC_ADDR:.*]] = cir.alloca "ic" {{.*}} init
// CIR-BEFORE: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}}
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval"
// CIR-BEFORE: cir.store %[[IC_ARG]], %[[IC_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[IC:.*]] = cir.load{{.*}} %[[IC_ADDR]]
diff --git a/clang/test/CIR/CodeGen/vla-pointer-arith.c b/clang/test/CIR/CodeGen/vla-pointer-arith.c
index 4ebe189d93462..e17f14c4bb18a 100644
--- a/clang/test/CIR/CodeGen/vla-pointer-arith.c
+++ b/clang/test/CIR/CodeGen/vla-pointer-arith.c
@@ -14,7 +14,7 @@ void test_vla_ptr_add(int n, int i) {
}
// CIR-LABEL: @test_vla_ptr_add
-// CIR: cir.alloca "arr" {{.*}}
+// CIR: cir.alloca "arr"
// CIR: %[[N2:.*]] = cir.load{{.*}} !cir.ptr<!s32i>, !s32i
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N2]] : !s32i -> !u64i
// CIR: %[[P:.*]] = cir.load{{.*}} !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -38,7 +38,7 @@ void test_vla_ptr_inc(int n) {
}
// CIR-LABEL: @test_vla_ptr_inc
-// CIR: cir.alloca "arr" {{.*}}
+// CIR: cir.alloca "arr"
// CIR: %[[N2:.*]] = cir.load{{.*}} !cir.ptr<!s32i>, !s32i
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N2]] : !s32i -> !u64i
// CIR: %[[P:.*]] = cir.load{{.*}} !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -57,7 +57,7 @@ void test_vla_ptr_dec(int n) {
}
// CIR-LABEL: @test_vla_ptr_dec
-// CIR: cir.alloca "arr" {{.*}}
+// CIR: cir.alloca "arr"
// CIR: %[[N2:.*]] = cir.load{{.*}} !cir.ptr<!s32i>, !s32i
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N2]] : !s32i -> !u64i
// CIR: %[[P:.*]] = cir.load{{.*}} !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
index ebb0d4c8cc015..a5ae216a938c7 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
@@ -12,7 +12,7 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca "this" {{.*}}
+ // CHECK-NEXT: cir.alloca "this"
// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
// CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
// CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
@@ -76,7 +76,7 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: cir.alloca "this" {{.*}}
+ // CHECK-NEXT: cir.alloca "this"
// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
// CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
// CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp b/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
index 7a777c6621f1a..aaed6298c77c3 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
@@ -91,7 +91,7 @@ void NormalFunc(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
// CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
// CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}}
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt"
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
HasSideEffects *LocalHSE;
diff --git a/clang/test/CIR/CodeGenOpenMP/parallel.c b/clang/test/CIR/CodeGenOpenMP/parallel.c
index d36a9e30fa447..36a48b38ee789 100644
--- a/clang/test/CIR/CodeGenOpenMP/parallel.c
+++ b/clang/test/CIR/CodeGenOpenMP/parallel.c
@@ -34,8 +34,8 @@ void emit_simple_parallel() {
void parallel_with_operations() {
// CHECK: cir.func{{.*}}@parallel_with_operations
int a, b;
- // CHECK-NEXT: cir.alloca "a" {{.*}}
- // CHECK-NEXT: cir.alloca "b" {{.*}}
+ // CHECK-NEXT: cir.alloca "a"
+ // CHECK-NEXT: cir.alloca "b"
// TODO(OMP): At the moment this results in 3 NYI diagnostics, 1 each for the
// clauses + 1 for the CapturedStmt. When those are implemented, the check
// lines will need updating.
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
index 30dd1e88e3e01..49a889d753e6e 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
@@ -612,8 +612,8 @@ cir.func @test_goto_within_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_within_nested_cleanup()
-// CHECK: %[[A1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass{{.*}}
-// CHECK: %[[A2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass{{.*}}
+// CHECK: %[[A1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass
+// CHECK: %[[A2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass
// CHECK: cir.call @ctor(%[[A1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
>From ee1c1a1dcae9885084217f406dd8375dcbe2002e Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Wed, 27 May 2026 22:59:13 -0500
Subject: [PATCH 5/7] Fix new tests
---
clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp | 8 ++++----
clang/test/CIR/CodeGen/try-catch.cpp | 2 +-
2 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp b/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp
index c7cf0b03422a8..b7da3d2e046b0 100644
--- a/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp
@@ -17,8 +17,8 @@ void testSwitchWithCleanup(int n) {
// region runs the destructor for `x` on the EH unwind path.
// CIR: cir.func{{.*}} @_Z21testSwitchWithCleanupi(%[[ARG:.*]]: !s32i
-// CIR: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR: %[[X:.*]] = cir.alloca !rec_Local, !cir.ptr<!rec_Local>, ["x"]
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} !rec_Local -> !cir.ptr<!rec_Local>
// CIR: cir.store %[[ARG]], %[[N_ADDR]] : !s32i
// CIR: cir.cleanup.scope {
// CIR: %[[EXN:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i>
@@ -39,8 +39,8 @@ void testSwitchWithCleanup(int n) {
// cleanup chain that runs the destructor and then resumes.
// CIR-FLAT: cir.func{{.*}} @_Z21testSwitchWithCleanupi(%[[ARG:.*]]: !s32i
-// CIR-FLAT: %[[N_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["n", init]
-// CIR-FLAT: %[[X:.*]] = cir.alloca !rec_Local, !cir.ptr<!rec_Local>, ["x"]
+// CIR-FLAT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-FLAT: %[[X:.*]] = cir.alloca "x" {{.*}} !rec_Local -> !cir.ptr<!rec_Local>
// CIR-FLAT: cir.store %[[ARG]], %[[N_ADDR]]
// CIR-FLAT: cir.br ^[[BODY:.+]]
// CIR-FLAT: ^[[BODY]]:
diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp
index 94b2dd2e67ad4..674a2c8aa3544 100644
--- a/clang/test/CIR/CodeGen/try-catch.cpp
+++ b/clang/test/CIR/CodeGen/try-catch.cpp
@@ -1772,7 +1772,7 @@ void direct_inside_try_catch_with_exception_type() {
// CIR: cir.func {{.*}} @_Z43direct_inside_try_catch_with_exception_typev() personality(@__gxx_personality_v0)
// CIR: cir.scope {
-// CIR: %[[E:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["e"]
+// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} !s32i -> !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: %[[EXN:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i>
// CIR: %[[FORTYTWO:.*]] = cir.const #cir.int<42> : !s32i
>From 4d71183757acd1cb0e89693fcaaf6f6288e71c14 Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Wed, 3 Jun 2026 18:47:32 -0500
Subject: [PATCH 6/7] Update assembly format and tests
---
.../CIR/Dialect/Builder/CIRBaseBuilder.h | 19 +-
clang/include/clang/CIR/Dialect/IR/CIROps.td | 27 +--
clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp | 24 +-
clang/lib/CIR/CodeGen/CIRGenExpr.cpp | 4 +-
clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp | 13 +-
clang/lib/CIR/CodeGen/CIRGenStmtOpenACC.cpp | 2 +-
clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 5 +-
.../CIR/Dialect/Transforms/CXXABILowering.cpp | 4 +-
.../lib/CIR/Dialect/Transforms/FlattenCFG.cpp | 8 +-
.../Dialect/Transforms/LoweringPrepare.cpp | 6 +-
.../CodeGen/abi-lower-after-unreachable.cpp | 2 +-
clang/test/CIR/CodeGen/abstract-cond.c | 20 +-
clang/test/CIR/CodeGen/agg-expr-lvalue.c | 14 +-
clang/test/CIR/CodeGen/agg-init-constexpr.cpp | 2 +-
.../CodeGen/amdgpu-call-addrspace-cast.cpp | 2 +-
.../amdgpu-stack-alloca-array-decay.cpp | 4 +-
clang/test/CIR/CodeGen/array-ctor.cpp | 16 +-
clang/test/CIR/CodeGen/array-dtor.cpp | 16 +-
.../CIR/CodeGen/array-init-loop-exprs.cpp | 16 +-
clang/test/CIR/CodeGen/array.cpp | 58 ++---
clang/test/CIR/CodeGen/assign-operator.cpp | 20 +-
clang/test/CIR/CodeGen/assume-attr.cpp | 6 +-
clang/test/CIR/CodeGen/atomic-thread-fence.c | 12 +-
clang/test/CIR/CodeGen/atomic.c | 28 +--
clang/test/CIR/CodeGen/base-to-derived.cpp | 6 +-
clang/test/CIR/CodeGen/basic.c | 22 +-
clang/test/CIR/CodeGen/basic.cpp | 32 +--
clang/test/CIR/CodeGen/binassign.c | 24 +-
clang/test/CIR/CodeGen/binop.cpp | 46 ++--
clang/test/CIR/CodeGen/bitfield-union.c | 2 +-
clang/test/CIR/CodeGen/bitfields.c | 14 +-
clang/test/CIR/CodeGen/bitfields.cpp | 6 +-
clang/test/CIR/CodeGen/bitfields_be.c | 4 +-
clang/test/CIR/CodeGen/builtins-x86.c | 4 +-
.../CodeGen/call-via-class-member-funcptr.cpp | 4 +-
clang/test/CIR/CodeGen/call.c | 4 +-
clang/test/CIR/CodeGen/call.cpp | 6 +-
clang/test/CIR/CodeGen/cast-cxx20.cpp | 16 +-
clang/test/CIR/CodeGen/cast.c | 2 +-
clang/test/CIR/CodeGen/cast.cpp | 6 +-
clang/test/CIR/CodeGen/choose-expr.cpp | 8 +-
clang/test/CIR/CodeGen/class.cpp | 8 +-
.../test/CIR/CodeGen/cleanup-automatic-eh.cpp | 4 +-
.../CIR/CodeGen/cleanup-conditional-eh.cpp | 28 +--
.../cleanup-conditional-with-wrapper-eh.cpp | 26 +-
.../cleanup-conditional-with-wrapper.cpp | 26 +-
.../test/CIR/CodeGen/cleanup-conditional.cpp | 54 ++---
.../CIR/CodeGen/cleanup-scope-goto-out.cpp | 12 +-
.../CIR/CodeGen/cleanup-scope-goto-within.cpp | 4 +-
.../cleanup-scope-tmp-with-exception.cpp | 4 +-
clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp | 4 +-
.../CodeGen/cleanup-throw-from-cleanup.cpp | 8 +-
.../CIR/CodeGen/cleanup-throwing-dtor.cpp | 4 +-
clang/test/CIR/CodeGen/cleanup.cpp | 34 +--
clang/test/CIR/CodeGen/cmp.cpp | 28 +--
clang/test/CIR/CodeGen/comma.c | 8 +-
clang/test/CIR/CodeGen/complex-atomic-cast.c | 4 +-
clang/test/CIR/CodeGen/complex-builtins.cpp | 16 +-
clang/test/CIR/CodeGen/complex-cast.cpp | 4 +-
.../CodeGen/complex-compound-assignment.cpp | 58 ++---
clang/test/CIR/CodeGen/complex-mul-div.cpp | 90 +++----
clang/test/CIR/CodeGen/complex-plus-minus.cpp | 32 +--
clang/test/CIR/CodeGen/complex-unary.cpp | 88 +++----
clang/test/CIR/CodeGen/complex.cpp | 222 +++++++++---------
clang/test/CIR/CodeGen/compound_literal.cpp | 14 +-
.../CIR/CodeGen/concept-specialization.cpp | 2 +-
clang/test/CIR/CodeGen/constant-expr.cpp | 6 +-
clang/test/CIR/CodeGen/copy-constructor.cpp | 4 +-
clang/test/CIR/CodeGen/coro-task.cpp | 66 +++---
clang/test/CIR/CodeGen/count-of.c | 8 +-
.../test/CIR/CodeGen/ctor-alias-prev-decl.cpp | 4 +-
clang/test/CIR/CodeGen/ctor-alias.cpp | 8 +-
clang/test/CIR/CodeGen/ctor-null-init.cpp | 6 +-
clang/test/CIR/CodeGen/ctor-try-body.cpp | 4 +-
clang/test/CIR/CodeGen/ctor.cpp | 8 +-
.../CIR/CodeGen/cxx-conversion-operators.cpp | 10 +-
.../CodeGen/cxx-rewritten-binary-operator.cpp | 6 +-
clang/test/CIR/CodeGen/cxx-traits.cpp | 14 +-
.../CodeGen/cxx23-explicit-object-member.cpp | 2 +-
clang/test/CIR/CodeGen/defaultarg.cpp | 4 +-
clang/test/CIR/CodeGen/deferred-fn-defs.cpp | 2 +-
.../CodeGen/delegating-ctor-exceptions.cpp | 2 +-
clang/test/CIR/CodeGen/delegating-ctor.cpp | 6 +-
.../CIR/CodeGen/delete-array-unsized-dtor.cpp | 2 +-
clang/test/CIR/CodeGen/delete-array.cpp | 2 +-
clang/test/CIR/CodeGen/delete-destroying.cpp | 6 +-
clang/test/CIR/CodeGen/delete.cpp | 2 +-
clang/test/CIR/CodeGen/derived-to-base.cpp | 8 +-
clang/test/CIR/CodeGen/destructors.cpp | 6 +-
.../test/CIR/CodeGen/dtor-alias-prev-decl.cpp | 4 +-
clang/test/CIR/CodeGen/dtor-alias.cpp | 6 +-
clang/test/CIR/CodeGen/dtors.cpp | 28 +--
clang/test/CIR/CodeGen/embed-expr.c | 6 +-
clang/test/CIR/CodeGen/empty-union.c | 4 +-
clang/test/CIR/CodeGen/empty-union.cpp | 4 +-
clang/test/CIR/CodeGen/fixed-point-literal.c | 24 +-
clang/test/CIR/CodeGen/forrange.cpp | 40 ++--
clang/test/CIR/CodeGen/generic-selection.c | 4 +-
clang/test/CIR/CodeGen/global-array-dtor.cpp | 2 +-
clang/test/CIR/CodeGen/global-init.cpp | 2 +-
clang/test/CIR/CodeGen/gnu-null.cpp | 4 +-
clang/test/CIR/CodeGen/gnu-ptr-math.c | 32 +--
clang/test/CIR/CodeGen/if.cpp | 4 +-
clang/test/CIR/CodeGen/implicit-return-zero.c | 4 +-
.../CIR/CodeGen/implicit-value-init-expr.cpp | 4 +-
clang/test/CIR/CodeGen/inherited-ctors.cpp | 14 +-
clang/test/CIR/CodeGen/init-list-lvalue.cpp | 16 +-
.../CodeGen/initializer-list-two-pointers.cpp | 4 +-
clang/test/CIR/CodeGen/inline-asm.c | 108 ++++-----
clang/test/CIR/CodeGen/inline-cxx-func.cpp | 6 +-
clang/test/CIR/CodeGen/instantiate-init.cpp | 6 +-
clang/test/CIR/CodeGen/kr-func-promote.c | 4 +-
clang/test/CIR/CodeGen/label-values.c | 10 +-
clang/test/CIR/CodeGen/label.c | 2 +-
.../CodeGen/lambda-decomp-decl-captures.cpp | 24 +-
clang/test/CIR/CodeGen/lambda-dtor-field.cpp | 14 +-
.../lambda-static-invoker-agg-return.cpp | 6 +-
.../CIR/CodeGen/lambda-static-invoker.cpp | 34 +--
clang/test/CIR/CodeGen/lambda.cpp | 48 ++--
clang/test/CIR/CodeGen/launder.cpp | 16 +-
clang/test/CIR/CodeGen/local-vars.cpp | 48 ++--
.../test/CIR/CodeGen/long-double-inc-dec.cpp | 16 +-
clang/test/CIR/CodeGen/loop.cpp | 10 +-
clang/test/CIR/CodeGen/mem-expr-fn.cpp | 4 +-
clang/test/CIR/CodeGen/member-functions.cpp | 10 +-
.../test/CIR/CodeGen/new-array-in-ternary.cpp | 8 +-
.../CIR/CodeGen/new-delete-deactivation.cpp | 16 +-
clang/test/CIR/CodeGen/new-delete.cpp | 46 ++--
clang/test/CIR/CodeGen/new.cpp | 38 +--
clang/test/CIR/CodeGen/no-odr-use.cpp | 2 +-
clang/test/CIR/CodeGen/noexcept.cpp | 6 +-
.../CIR/CodeGen/non-scalar-lval-return.cpp | 4 +-
.../CIR/CodeGen/non-type-template-param.cpp | 2 +-
clang/test/CIR/CodeGen/nonzeroinit-struct.cpp | 8 +-
clang/test/CIR/CodeGen/nrvo.cpp | 10 +-
clang/test/CIR/CodeGen/nullptr-init.cpp | 6 +-
clang/test/CIR/CodeGen/opaque.c | 6 +-
clang/test/CIR/CodeGen/opaque.cpp | 32 +--
.../CIR/CodeGen/openmp_default_simd_align.c | 2 +-
clang/test/CIR/CodeGen/pack-indexing.cpp | 16 +-
clang/test/CIR/CodeGen/paren-init-list-eh.cpp | 2 +-
clang/test/CIR/CodeGen/paren-init-list.cpp | 4 +-
.../test/CIR/CodeGen/paren-list-agg-init.cpp | 92 ++++----
.../CIR/CodeGen/partial-array-cleanup.cpp | 46 ++--
clang/test/CIR/CodeGen/pass-object-size.c | 4 +-
clang/test/CIR/CodeGen/placement-new.cpp | 2 +-
.../CodeGen/pointer-to-data-member-cast.cpp | 4 +-
.../CIR/CodeGen/pointer-to-data-member.cpp | 30 +--
.../CodeGen/pointer-to-member-func-cast.cpp | 8 +-
.../CIR/CodeGen/pointer-to-member-func.cpp | 12 +-
clang/test/CIR/CodeGen/replace-global.cpp | 2 +-
clang/test/CIR/CodeGen/requires-expr.cpp | 4 +-
clang/test/CIR/CodeGen/self-assign.c | 2 +-
clang/test/CIR/CodeGen/size-of-vla.cpp | 24 +-
clang/test/CIR/CodeGen/source-loc.cpp | 10 +-
clang/test/CIR/CodeGen/statement-exprs.c | 30 +--
.../CIR/CodeGen/static-local-arm-guard.cpp | 2 +-
clang/test/CIR/CodeGen/static-local.cpp | 34 +--
clang/test/CIR/CodeGen/stmt-expr.cpp | 14 +-
clang/test/CIR/CodeGen/string-literals.cpp | 2 +-
clang/test/CIR/CodeGen/struct-init.cpp | 20 +-
clang/test/CIR/CodeGen/struct.c | 4 +-
clang/test/CIR/CodeGen/struct.cpp | 44 ++--
clang/test/CIR/CodeGen/switch.cpp | 10 +-
clang/test/CIR/CodeGen/switch_flat_op.cpp | 6 +-
.../test/CIR/CodeGen/temp-param-obj-decl.cpp | 4 +-
.../temporary-materialization-adjust.cpp | 14 +-
.../CIR/CodeGen/temporary-materialization.cpp | 10 +-
clang/test/CIR/CodeGen/ternary-throw.cpp | 44 ++--
clang/test/CIR/CodeGen/ternary.cpp | 38 +--
.../test/CIR/CodeGen/thread-local-in-func.cpp | 16 +-
clang/test/CIR/CodeGen/three-way-cmp.cpp | 16 +-
clang/test/CIR/CodeGen/throws.cpp | 12 +-
clang/test/CIR/CodeGen/thunks.cpp | 2 +-
.../CIR/CodeGen/trivial-ctor-const-init.cpp | 2 +-
.../CodeGen/try-catch-all-with-cleanup.cpp | 10 +-
.../CodeGen/try-catch-non-trivial-copy.cpp | 8 +-
clang/test/CIR/CodeGen/try-catch.cpp | 34 +--
.../CIR/CodeGen/try-no-throwing-calls.cpp | 2 +-
clang/test/CIR/CodeGen/typedef.c | 2 +-
clang/test/CIR/CodeGen/unary.cpp | 42 ++--
clang/test/CIR/CodeGen/union-agg-init.c | 4 +-
clang/test/CIR/CodeGen/union-agg-init.cpp | 4 +-
clang/test/CIR/CodeGen/union.c | 12 +-
clang/test/CIR/CodeGen/var-arg-aggregate.c | 6 +-
clang/test/CIR/CodeGen/var_arg.c | 18 +-
.../CIR/CodeGen/variable-decomposition.cpp | 4 +-
clang/test/CIR/CodeGen/vbase.cpp | 6 +-
clang/test/CIR/CodeGen/vector-ext-element.cpp | 62 ++---
clang/test/CIR/CodeGen/vector-ext.cpp | 144 ++++++------
clang/test/CIR/CodeGen/vector.cpp | 146 ++++++------
.../CIR/CodeGen/virtual-destructor-calls.cpp | 4 +-
.../test/CIR/CodeGen/virtual-fn-calls-eh.cpp | 4 +-
.../CIR/CodeGen/virtual-function-calls.cpp | 6 +-
clang/test/CIR/CodeGen/vla.c | 58 ++---
.../CodeGenBuiltins/builtin-address-of.cpp | 4 +-
.../CIR/CodeGenBuiltins/builtin-bcopy.cpp | 8 +-
.../CIR/CodeGenBuiltins/builtin-bit-cast.cpp | 2 +-
.../test/CIR/CodeGenBuiltins/builtin-call.cpp | 6 +-
.../CIR/CodeGenBuiltins/builtin-constant-p.c | 20 +-
.../CIR/CodeGenBuiltins/builtin-fcmp-sse.c | 24 +-
.../CIR/CodeGenBuiltins/builtin-offset-of.cpp | 16 +-
.../CIR/CodeGenBuiltins/builtin-prefetch.c | 2 +-
.../CIR/CodeGenBuiltins/builtin-printf.cpp | 4 +-
.../CodeGenBuiltins/builtin-setjmp-longjmp.c | 4 +-
.../CIR/CodeGenBuiltins/builtin-signbit.c | 16 +-
clang/test/CIR/CodeGenCUDA/address-spaces.cu | 2 +-
clang/test/CIR/CodeGenCUDA/device-printf.cu | 2 +-
clang/test/CIR/CodeGenCUDA/kernel-call.cu | 24 +-
clang/test/CIR/CodeGenCXX/global-refs.cpp | 2 +-
clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp | 2 +-
.../new-array-init-list-non-trivial-dtor.cpp | 4 +-
clang/test/CIR/CodeGenCXX/new-array-init.cpp | 12 +-
.../simple-reinterpret-const-cast.cpp | 4 +-
clang/test/CIR/CodeGenCXX/sizeof-pack.cpp | 8 +-
clang/test/CIR/CodeGenCXX/typeid.cpp | 2 +-
.../CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp | 4 +-
.../test/CIR/CodeGenCXX/x86_64-arguments.cpp | 4 +-
.../CIR/CodeGenOpenACC/atomic-capture.cpp | 50 ++--
clang/test/CIR/CodeGenOpenACC/atomic-read.cpp | 6 +-
.../test/CIR/CodeGenOpenACC/atomic-update.cpp | 24 +-
.../test/CIR/CodeGenOpenACC/atomic-write.cpp | 8 +-
clang/test/CIR/CodeGenOpenACC/cache.c | 4 +-
clang/test/CIR/CodeGenOpenACC/combined-copy.c | 22 +-
.../test/CIR/CodeGenOpenACC/combined-copy.cpp | 4 +-
.../combined-copyin-copyout-create.c | 6 +-
.../combined-firstprivate-clause.cpp | 62 ++---
.../combined-private-clause.cpp | 52 ++--
.../combined-reduction-clause-default-ops.cpp | 108 ++++-----
.../combined-reduction-clause-float.cpp | 72 +++---
.../combined-reduction-clause-inline-ops.cpp | 152 ++++++------
.../combined-reduction-clause-int.cpp | 108 ++++-----
.../combined-reduction-clause-outline-ops.cpp | 152 ++++++------
clang/test/CIR/CodeGenOpenACC/combined.cpp | 8 +-
clang/test/CIR/CodeGenOpenACC/compute-copy.c | 20 +-
.../test/CIR/CodeGenOpenACC/compute-copy.cpp | 4 +-
.../compute-copyin-copyout-create.c | 6 +-
.../compute-firstprivate-clause-templates.cpp | 16 +-
.../compute-firstprivate-clause.c | 30 +--
.../compute-firstprivate-clause.cpp | 62 ++---
.../compute-private-clause-templates.cpp | 16 +-
.../CodeGenOpenACC/compute-private-clause.c | 24 +-
.../CodeGenOpenACC/compute-private-clause.cpp | 52 ++--
.../compute-reduction-clause-default-ops.c | 108 ++++-----
.../compute-reduction-clause-default-ops.cpp | 108 ++++-----
.../compute-reduction-clause-float.c | 72 +++---
.../compute-reduction-clause-float.cpp | 72 +++---
.../compute-reduction-clause-inline-ops.cpp | 152 ++++++------
.../compute-reduction-clause-int.c | 108 ++++-----
.../compute-reduction-clause-int.cpp | 108 ++++-----
.../compute-reduction-clause-outline-ops.cpp | 152 ++++++------
.../compute-reduction-clause-unsigned-int.c | 108 ++++-----
.../data-copy-copyin-copyout-create.c | 4 +-
clang/test/CIR/CodeGenOpenACC/data.c | 4 +-
.../test/CIR/CodeGenOpenACC/declare-copy.cpp | 36 +--
.../CIR/CodeGenOpenACC/declare-copyin.cpp | 40 ++--
.../CIR/CodeGenOpenACC/declare-copyout.cpp | 40 ++--
.../CIR/CodeGenOpenACC/declare-create.cpp | 36 +--
.../CIR/CodeGenOpenACC/declare-deviceptr.cpp | 28 +--
.../CodeGenOpenACC/declare-deviceresident.cpp | 36 +--
.../CIR/CodeGenOpenACC/declare-present.cpp | 36 +--
clang/test/CIR/CodeGenOpenACC/enter-data.c | 4 +-
clang/test/CIR/CodeGenOpenACC/exit-data.c | 4 +-
.../firstprivate-clause-recipes.cpp | 62 ++---
clang/test/CIR/CodeGenOpenACC/host_data.c | 8 +-
clang/test/CIR/CodeGenOpenACC/init.c | 2 +-
clang/test/CIR/CodeGenOpenACC/kernels.c | 6 +-
.../CodeGenOpenACC/loop-private-clause.cpp | 52 ++--
.../loop-reduction-clause-default-ops.cpp | 108 ++++-----
.../loop-reduction-clause-float.cpp | 72 +++---
.../loop-reduction-clause-inline-ops.cpp | 152 ++++++------
.../loop-reduction-clause-int.cpp | 108 ++++-----
.../loop-reduction-clause-outline-ops.cpp | 152 ++++++------
clang/test/CIR/CodeGenOpenACC/loop.cpp | 8 +-
clang/test/CIR/CodeGenOpenACC/parallel.c | 6 +-
.../private-clause-array-recipes-CtorDtor.cpp | 62 ++---
.../private-clause-array-recipes-NoOps.cpp | 38 +--
.../private-clause-array-recipes-int.cpp | 14 +-
...-clause-pointer-array-recipes-CtorDtor.cpp | 208 ++++++++--------
...ate-clause-pointer-array-recipes-NoOps.cpp | 164 ++++++-------
...ivate-clause-pointer-array-recipes-int.cpp | 120 +++++-----
...rivate-clause-pointer-recipes-CtorDtor.cpp | 82 +++----
.../private-clause-pointer-recipes-NoOps.cpp | 70 +++---
.../private-clause-pointer-recipes-int.cpp | 58 ++---
.../reduction-clause-recipes.cpp | 80 +++----
clang/test/CIR/CodeGenOpenACC/serial.c | 6 +-
clang/test/CIR/CodeGenOpenACC/set.c | 2 +-
clang/test/CIR/CodeGenOpenACC/shutdown.c | 2 +-
clang/test/CIR/CodeGenOpenACC/update.c | 4 +-
clang/test/CIR/CodeGenOpenACC/wait.c | 2 +-
clang/test/CIR/CodeGenOpenCL/as_type.cl | 12 +-
clang/test/CIR/CodeGenOpenCL/vector.cl | 16 +-
clang/test/CIR/CodeGenOpenMP/omp-llvmir.c | 6 +-
clang/test/CIR/IR/alloca.cir | 44 ++--
clang/test/CIR/IR/array-ctor.cir | 4 +-
clang/test/CIR/IR/array-dtor.cir | 4 +-
clang/test/CIR/IR/array.cir | 12 +-
clang/test/CIR/IR/binassign.cir | 16 +-
clang/test/CIR/IR/bitfield_info.cir | 2 +-
clang/test/CIR/IR/cmp.cir | 60 ++---
clang/test/CIR/IR/construct-catch-param.cir | 4 +-
clang/test/CIR/IR/func-attrs.cir | 16 +-
clang/test/CIR/IR/func.cir | 2 +-
clang/test/CIR/IR/indirect-br.cir | 8 +-
clang/test/CIR/IR/inline-asm.cir | 6 +-
clang/test/CIR/IR/invalid-complex.cir | 6 +-
.../CIR/IR/invalid-construct-catch-param.cir | 14 +-
clang/test/CIR/IR/invalid-data-member.cir | 4 +-
clang/test/CIR/IR/invalid-throw.cir | 2 +-
clang/test/CIR/IR/invalid-try-catch.cir | 2 +-
clang/test/CIR/IR/method-attr.cir | 12 +-
clang/test/CIR/IR/resume-flat.cir | 8 +-
clang/test/CIR/IR/struct.cir | 8 +-
clang/test/CIR/IR/throw.cir | 12 +-
clang/test/CIR/IR/unary.cir | 8 +-
clang/test/CIR/IR/vector.cir | 68 +++---
clang/test/CIR/IR/vtable-addrpt.cir | 2 +-
clang/test/CIR/IR/vtt-addrpoint.cir | 6 +-
clang/test/CIR/Lowering/address-space.cir | 6 +-
clang/test/CIR/Lowering/alloca.cir | 2 +-
clang/test/CIR/Lowering/binop-bool.cir | 4 +-
clang/test/CIR/Lowering/binop-fp.cir | 12 +-
clang/test/CIR/Lowering/binop-signed-int.cir | 6 +-
.../test/CIR/Lowering/binop-unsigned-int.cir | 6 +-
clang/test/CIR/Lowering/cast.cir | 22 +-
clang/test/CIR/Lowering/goto.cir | 4 +-
clang/test/CIR/Lowering/inline-asm.cir | 6 +-
clang/test/CIR/Lowering/omp-target-map.cir | 2 +-
clang/test/CIR/Lowering/resume-flat.cir | 4 +-
clang/test/CIR/Lowering/switch.cir | 8 +-
clang/test/CIR/Lowering/vtt-addrpoint.cir | 6 +-
clang/test/CIR/Transforms/canonicalize.cir | 4 +-
.../CIR/Transforms/complex-create-fold.cir | 8 +-
.../test/CIR/Transforms/complex-imag-fold.cir | 4 +-
.../test/CIR/Transforms/complex-real-fold.cir | 4 +-
...h-abi-lowering-construct-catch-invalid.cir | 6 +-
.../eh-abi-lowering-construct-catch.cir | 6 +-
.../Transforms/eh-abi-lowering-itanium.cir | 10 +-
.../Transforms/flatten-cleanup-scope-eh.cir | 60 ++---
.../flatten-cleanup-scope-multi-exit.cir | 136 +++++------
.../flatten-cleanup-scope-simple.cir | 68 +++---
.../flatten-throwing-in-cleanup.cir | 10 +-
clang/test/CIR/Transforms/flatten-try-op.cir | 28 +--
clang/test/CIR/Transforms/goto_solver.cir | 6 +-
clang/test/CIR/Transforms/hoist-allocas.cir | 12 +-
clang/test/CIR/Transforms/mem2reg.cir | 4 +-
clang/test/CIR/Transforms/scope.cir | 8 +-
clang/test/CIR/Transforms/switch-fold.cir | 12 +-
clang/test/CIR/Transforms/switch.cir | 18 +-
clang/test/CIR/Transforms/ternary-fold.cir | 4 +-
clang/test/CIR/Transforms/ternary.cir | 8 +-
.../CIR/Transforms/vector-extract-fold.cir | 8 +-
clang/test/CIR/func-simple.cpp | 16 +-
clang/unittests/CIR/PointerLikeTest.cpp | 12 +-
354 files changed, 4223 insertions(+), 4251 deletions(-)
diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
index a29fb45e95032..c2533fd3f7268 100644
--- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
+++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
@@ -301,10 +301,9 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
}
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType,
- mlir::Type type, llvm::StringRef name,
- mlir::IntegerAttr alignment,
+ llvm::StringRef name, mlir::IntegerAttr alignment,
mlir::Value dynAllocSize) {
- return cir::AllocaOp::create(*this, loc, addrType, type, name, alignment,
+ return cir::AllocaOp::create(*this, loc, addrType, name, alignment,
dynAllocSize);
}
@@ -313,20 +312,18 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
clang::CharUnits alignment,
mlir::Value dynAllocSize) {
mlir::IntegerAttr alignmentAttr = getAlignmentAttr(alignment);
- return createAlloca(loc, addrType, type, name, alignmentAttr, dynAllocSize);
+ return createAlloca(loc, addrType, name, alignmentAttr, dynAllocSize);
}
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType,
- mlir::Type type, llvm::StringRef name,
- mlir::IntegerAttr alignment) {
- return cir::AllocaOp::create(*this, loc, addrType, type, name, alignment);
+ llvm::StringRef name, mlir::IntegerAttr alignment) {
+ return cir::AllocaOp::create(*this, loc, addrType, name, alignment);
}
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType,
- mlir::Type type, llvm::StringRef name,
- clang::CharUnits alignment) {
+ llvm::StringRef name, clang::CharUnits alignment) {
mlir::IntegerAttr alignmentAttr = getAlignmentAttr(alignment);
- return createAlloca(loc, addrType, type, name, alignmentAttr);
+ return createAlloca(loc, addrType, name, alignmentAttr);
}
/// Get constant address of a global variable as an MLIR attribute.
@@ -423,7 +420,7 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
mlir::Value createDummyValue(mlir::Location loc, mlir::Type type,
clang::CharUnits alignment) {
mlir::IntegerAttr alignmentAttr = getAlignmentAttr(alignment);
- auto addr = createAlloca(loc, getPointerTo(type), type, {}, alignmentAttr);
+ auto addr = createAlloca(loc, getPointerTo(type), {}, alignmentAttr);
return cir::LoadOp::create(*this, loc, addr, /*isDeref=*/false,
/*isVolatile=*/false, alignmentAttr,
/*sync_scope=*/{}, /*mem_order=*/{});
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index d32cd5177b3ac..53582070ef7c5 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -567,21 +567,7 @@ def CIR_SyncScopeKind : CIR_I32EnumAttr<"SyncScopeKind", "sync scope kind", [
// AllocaOp
//===----------------------------------------------------------------------===//
-class CIR_AllocaTypesMatchWith<
- string summary, string lhsArg, string rhsArg, string transform,
- string comparator = "std::equal_to<>()"
-> : PredOpTrait<summary, CPred<comparator # "(" #
- !subst("$_self", "$" # lhsArg # ".getType()", transform) #
- ", $" # rhsArg # ")">
-> {
- string lhs = lhsArg;
- string rhs = rhsArg;
- string transformer = transform;
-}
-
def CIR_AllocaOp : CIR_Op<"alloca", [
- CIR_AllocaTypesMatchWith<"'allocaType' matches pointee type of 'addr'",
- "addr", "allocaType", "mlir::cast<cir::PointerType>($_self).getPointee()">,
DeclareOpInterfaceMethods<PromotableAllocationOpInterface>
]> {
let summary = "Defines a scope-local variable";
@@ -614,8 +600,7 @@ def CIR_AllocaOp : CIR_Op<"alloca", [
}];
let arguments = (ins
- Optional<CIR_AnyFundamentalIntType>:$dynAllocSize,
- TypeAttr:$allocaType,
+ Optional<CIR_UInt64>:$dynAllocSize,
StrAttr:$name,
UnitAttr:$init,
UnitAttr:$constant,
@@ -630,23 +615,24 @@ def CIR_AllocaOp : CIR_Op<"alloca", [
let skipDefaultBuilders = 1;
let builders = [
OpBuilder<(ins "mlir::Type":$addr,
- "mlir::Type":$allocaType,
"llvm::StringRef":$name,
"mlir::IntegerAttr":$alignment)>,
OpBuilder<(ins "mlir::Type":$addr,
- "mlir::Type":$allocaType,
"llvm::StringRef":$name,
"mlir::IntegerAttr":$alignment,
"mlir::Value":$dynAllocSize),
[{
if (dynAllocSize)
$_state.addOperands(dynAllocSize);
- build($_builder, $_state, addr, allocaType, name, alignment);
+ build($_builder, $_state, addr, name, alignment);
}]>
];
let extraClassDeclaration = [{
+ mlir::Type getAllocaType() {
+ return mlir::cast<cir::PointerType>(getAddr().getType()).getPointee();
+ }
// Whether the alloca input type is a pointer.
bool isPointerType() { return ::mlir::isa<::cir::PointerType>(getAllocaType()); }
bool isDynamic() { return (bool)getDynAllocSize(); }
@@ -658,8 +644,7 @@ def CIR_AllocaOp : CIR_Op<"alloca", [
oilist( `init` $init
| `const` $constant
| `cleanup_dest_slot` $cleanup_dest_slot)
- ($dynAllocSize^ `:` type($dynAllocSize) `,`)?
- $allocaType `->` qualified(type($addr))
+ (`size` `(` $dynAllocSize^ `)`)? `:` qualified(type($addr))
($annotations^)? attr-dict
}];
diff --git a/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp b/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp
index 5f1d43ac752da..65a3c2a7468e9 100644
--- a/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenCUDANV.cpp
@@ -131,9 +131,9 @@ mlir::Value CIRGenNVCUDARuntime::prepareKernelArgs(CIRGenFunction &cgf,
// Build void *args[] and populate with the addresses of kernel arguments.
auto voidPtrArrayTy = cir::ArrayType::get(cgm.voidPtrTy, args.size());
- mlir::Value kernelArgs = builder.createAlloca(
- loc, cir::PointerType::get(voidPtrArrayTy), voidPtrArrayTy, "kernel_args",
- CharUnits::fromQuantity(16));
+ mlir::Value kernelArgs =
+ builder.createAlloca(loc, cir::PointerType::get(voidPtrArrayTy),
+ "kernel_args", CharUnits::fromQuantity(16));
mlir::Value kernelArgsDecayed =
builder.createCast(cir::CastKind::array_to_ptrdecay, kernelArgs,
@@ -223,17 +223,15 @@ void CIRGenNVCUDARuntime::emitDeviceStubBodyNew(CIRGenFunction &cgf,
cudaLaunchKernelFD->getParamDecl(5)->getType());
mlir::Value gridDim =
- builder.createAlloca(loc, cir::PointerType::get(dim3Ty), dim3Ty,
- "grid_dim", CharUnits::fromQuantity(8));
+ builder.createAlloca(loc, cir::PointerType::get(dim3Ty), "grid_dim",
+ CharUnits::fromQuantity(8));
mlir::Value blockDim =
- builder.createAlloca(loc, cir::PointerType::get(dim3Ty), dim3Ty,
- "block_dim", CharUnits::fromQuantity(8));
- mlir::Value sharedMem =
- builder.createAlloca(loc, cir::PointerType::get(cgm.sizeTy), cgm.sizeTy,
- "shared_mem", cgm.getSizeAlign());
- mlir::Value stream =
- builder.createAlloca(loc, cir::PointerType::get(streamTy), streamTy,
- "stream", cgm.getPointerAlign());
+ builder.createAlloca(loc, cir::PointerType::get(dim3Ty), "block_dim",
+ CharUnits::fromQuantity(8));
+ mlir::Value sharedMem = builder.createAlloca(
+ loc, cir::PointerType::get(cgm.sizeTy), "shared_mem", cgm.getSizeAlign());
+ mlir::Value stream = builder.createAlloca(
+ loc, cir::PointerType::get(streamTy), "stream", cgm.getPointerAlign());
cir::FuncOp popConfig = cgm.createRuntimeFunction(
cir::FuncType::get({gridDim.getType(), blockDim.getType(),
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
index 2360b4123888c..4ab3b6be4e0ae 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -2705,8 +2705,8 @@ mlir::Value CIRGenFunction::emitAlloca(StringRef name, mlir::Type ty,
{
mlir::OpBuilder::InsertionGuard guard(builder);
builder.restoreInsertionPoint(ip);
- addr = builder.createAlloca(loc, /*addr type*/ localVarPtrTy,
- /*var type*/ ty, name, alignIntAttr, arraySize);
+ addr = builder.createAlloca(loc, /*addr type*/ localVarPtrTy, name,
+ alignIntAttr, arraySize);
assert(!cir::MissingFeatures::astVarDeclInterface());
}
return addr;
diff --git a/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp b/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
index eab045e186699..ea1fb2ce96edd 100644
--- a/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenOpenACCRecipe.cpp
@@ -51,8 +51,7 @@ void OpenACCRecipeBuilderBase::makeAllocaCopy(mlir::Location loc,
cgf.getContext().UnsignedLongLongTy));
auto loopBuilder = [&]() {
- auto itr =
- cir::AllocaOp::create(builder, loc, itrPtrTy, itrTy, "itr", itrAlign);
+ auto itr = cir::AllocaOp::create(builder, loc, itrPtrTy, "itr", itrAlign);
cir::ConstantOp constZero = builder.getConstInt(loc, itrTy, 0);
builder.CIRBaseBuilderTy::createStore(loc, constZero, itr);
builder.createFor(
@@ -141,7 +140,7 @@ mlir::Value OpenACCRecipeBuilderBase::makeBoundsAlloca(
cir::PointerType topLevelTyPtr = builder.getPointerTo(topLevelTy);
// Do an alloca for the 'top' level type without bounds.
mlir::Value initialAlloca = builder.createAlloca(
- loc, topLevelTyPtr, topLevelTy, allocaName,
+ loc, topLevelTyPtr, allocaName,
cgf.getContext().getTypeAlignInChars(boundTypes.back()));
bool lastBoundWasArray = isArrayTy(boundTypes.back());
@@ -261,8 +260,7 @@ std::pair<mlir::Value, mlir::Value> OpenACCRecipeBuilderBase::createBoundsLoop(
builder, loc, itrTy, upperBoundVal.getResult());
// Create a memory location for the iterator.
- auto itr =
- cir::AllocaOp::create(builder, loc, itrPtrTy, itrTy, "iter", itrAlign);
+ auto itr = cir::AllocaOp::create(builder, loc, itrPtrTy, "iter", itrAlign);
// Store to the iterator: either lower bound, or if inverse loop, upper
// bound.
if (inverse) {
@@ -620,9 +618,8 @@ void OpenACCRecipeBuilderBase::createReductionRecipeCombiner(
mlir::Value zero =
builder.getConstInt(loc, mlir::cast<cir::IntType>(cgf.ptrDiffTy), 0);
- mlir::Value itr =
- cir::AllocaOp::create(builder, loc, itrPtrTy, itrTy, "itr",
- cgf.cgm.getSize(cgf.getPointerAlign()));
+ mlir::Value itr = cir::AllocaOp::create(
+ builder, loc, itrPtrTy, "itr", cgf.cgm.getSize(cgf.getPointerAlign()));
builder.CIRBaseBuilderTy::createStore(loc, zero, itr);
builder.setInsertionPointAfter(builder.createFor(
diff --git a/clang/lib/CIR/CodeGen/CIRGenStmtOpenACC.cpp b/clang/lib/CIR/CodeGen/CIRGenStmtOpenACC.cpp
index 11aad17187fbc..71cbed1be6471 100644
--- a/clang/lib/CIR/CodeGen/CIRGenStmtOpenACC.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenStmtOpenACC.cpp
@@ -347,7 +347,7 @@ emitAtomicUpdate(CIRGenFunction &cgf, CIRGenBuilderTy &builder,
// nodes to worry about, so we can just count on opt to remove the extra
// alloca/load/store set.
auto alloca = cir::AllocaOp::create(
- builder, start, x.getType(), argTy, "x_var",
+ builder, start, x.getType(), "x_var",
cgf.cgm.getSize(
cgf.getContext().getTypeAlignInChars(inf.X->getType())));
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index cf07fc4f0833a..72e378dd031e7 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -292,10 +292,7 @@ void printGlobalAddressSpaceValue(mlir::AsmPrinter &printer, cir::GlobalOp op,
void cir::AllocaOp::build(mlir::OpBuilder &odsBuilder,
mlir::OperationState &odsState, mlir::Type addr,
- mlir::Type allocaType, llvm::StringRef name,
- mlir::IntegerAttr alignment) {
- odsState.addAttribute(getAllocaTypeAttrName(odsState.name),
- mlir::TypeAttr::get(allocaType));
+ llvm::StringRef name, mlir::IntegerAttr alignment) {
odsState.addAttribute(getNameAttrName(odsState.name),
odsBuilder.getStringAttr(name));
if (alignment) {
diff --git a/clang/lib/CIR/Dialect/Transforms/CXXABILowering.cpp b/clang/lib/CIR/Dialect/Transforms/CXXABILowering.cpp
index 1de49dfb5dc81..0bcfe124723e6 100644
--- a/clang/lib/CIR/Dialect/Transforms/CXXABILowering.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/CXXABILowering.cpp
@@ -332,12 +332,10 @@ mlir::LogicalResult CIRAllocaOpABILowering::matchAndRewrite(
cir::AllocaOp op, OpAdaptor adaptor,
mlir::ConversionPatternRewriter &rewriter) const {
mlir::Type allocaPtrTy = op.getType();
- mlir::Type allocaTy = op.getAllocaType();
mlir::Type loweredAllocaPtrTy = getTypeConverter()->convertType(allocaPtrTy);
- mlir::Type loweredAllocaTy = getTypeConverter()->convertType(allocaTy);
cir::AllocaOp loweredOp = cir::AllocaOp::create(
- rewriter, op.getLoc(), loweredAllocaPtrTy, loweredAllocaTy, op.getName(),
+ rewriter, op.getLoc(), loweredAllocaPtrTy, op.getName(),
op.getAlignmentAttr(), /*dynAllocSize=*/adaptor.getDynAllocSize());
loweredOp.setInit(op.getInit());
loweredOp.setConstant(op.getConstant());
diff --git a/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp b/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp
index 35a326275114b..ddeeb98fee820 100644
--- a/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/FlattenCFG.cpp
@@ -653,7 +653,7 @@ static cir::AllocaOp getOrCreateCleanupDestSlot(cir::FuncOp funcOp,
cir::CIRDataLayout dataLayout(funcOp->getParentOfType<mlir::ModuleOp>());
uint64_t alignment = dataLayout.getAlignment(s32Type, true).value();
auto allocaOp = cir::AllocaOp::create(
- rewriter, loc, ptrToS32Type, s32Type, "__cleanup_dest_slot",
+ rewriter, loc, ptrToS32Type, "__cleanup_dest_slot",
/*alignment=*/rewriter.getI64IntegerAttr(alignment));
allocaOp.setCleanupDestSlot(true);
return allocaOp;
@@ -960,9 +960,9 @@ class CIRCleanupScopeOpFlattening
uint64_t alignment =
dataLayout.getAlignment(operand.getType(), true).value();
cir::PointerType ptrType = cir::PointerType::get(operand.getType());
- alloca = cir::AllocaOp::create(rewriter, loc, ptrType,
- operand.getType(), "__ret_operand_tmp",
- rewriter.getI64IntegerAttr(alignment));
+ alloca =
+ cir::AllocaOp::create(rewriter, loc, ptrType, "__ret_operand_tmp",
+ rewriter.getI64IntegerAttr(alignment));
}
// Store the operand value at the original return location.
diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp
index cb10b695f73e7..05fd40607b6e1 100644
--- a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp
@@ -1925,9 +1925,9 @@ static void lowerArrayDtorCtorIntoLoop(cir::CIRBaseBuilderTy &builder,
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
}
- mlir::Value tmpAddr = builder.createAlloca(
- loc, /*addr type*/ builder.getPointerTo(eltTy),
- /*var type*/ eltTy, "__array_idx", builder.getAlignmentAttr(1));
+ mlir::Value tmpAddr =
+ builder.createAlloca(loc, /*addr type*/ builder.getPointerTo(eltTy),
+ "__array_idx", builder.getAlignmentAttr(1));
builder.createStore(loc, start, tmpAddr);
mlir::Block *bodyBlock = &op->getRegion(0).front();
diff --git a/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp b/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp
index eb048974adba7..6df3db00cf4b8 100644
--- a/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp
+++ b/clang/test/CIR/CodeGen/abi-lower-after-unreachable.cpp
@@ -19,7 +19,7 @@ void untransformed_after_unreachable(Base2 &ref, PMFTy pmf) {
// CIR-LABEL: cir.func {{.*}}@_Z31untransformed_after_unreachableR5Base2M7DerivedFvvE
// CIR: %[[PMF:.*]] = cir.alloca "pmf" {{.*}} init
-// CIR: %[[DERIVED:.*]] = cir.alloca {{.*}} !rec_Derived
+// CIR: %[[DERIVED:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_Derived>
// CIR: cir.load %{{.*}} : !cir.ptr<!cir.ptr<!rec_Base2>>, !cir.ptr<!rec_Base2>
// CIR-NEXT: cir.call @__cxa_bad_cast() {noreturn} : () -> ()
// CIR-NEXT: cir.unreachable
diff --git a/clang/test/CIR/CodeGen/abstract-cond.c b/clang/test/CIR/CodeGen/abstract-cond.c
index 11d2ee90211ef..00008ea876b7b 100644
--- a/clang/test/CIR/CodeGen/abstract-cond.c
+++ b/clang/test/CIR/CodeGen/abstract-cond.c
@@ -12,10 +12,10 @@ int test_agg_cond(int a0, struct s6 a1, struct s6 a2) {
}
// CIR: cir.func {{.*}} @test_agg_cond
-// CIR: %[[A0:.*]] = cir.alloca "a0" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A0:.*]] = cir.alloca "a0" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} : !cir.ptr<!rec_s6>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_s6>
// CIR: %[[LOAD_A0:.*]] = cir.load{{.*}} %[[A0]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[COND:.*]] = cir.cast int_to_bool %[[LOAD_A0]] : !s32i -> !cir.bool
// CIR: cir.if %[[COND]] {
@@ -60,16 +60,16 @@ int test_stmt_expr(int flag, struct s6 a1, struct s6 a2) {
}
// CIR: cir.func {{.*}} @test_stmt_expr
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} : !cir.ptr<!rec_s6>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_s6>
// CIR: %[[LOAD_FLAG:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[COND:.*]] = cir.cast int_to_bool %[[LOAD_FLAG]] : !s32i -> !cir.bool
// CIR: cir.if %[[COND]] {
-// CIR: %[[STMT_TMP:.*]] = cir.alloca "tmp" {{.*}} !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[STMT_TMP:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!rec_s6>
// CIR: cir.scope {
-// CIR: %[[T:.*]] = cir.alloca "t" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[T:.*]] = cir.alloca "t" {{.*}} init : !cir.ptr<!rec_s6>
// CIR: cir.copy %[[A1]] to %[[T]] : !cir.ptr<!rec_s6>
// CIR: cir.call @foo() : () -> ()
// CIR: cir.copy %[[T]] to %[[TMP]] : !cir.ptr<!rec_s6>
diff --git a/clang/test/CIR/CodeGen/agg-expr-lvalue.c b/clang/test/CIR/CodeGen/agg-expr-lvalue.c
index 43beff4f16ad4..51109d3082ab0 100644
--- a/clang/test/CIR/CodeGen/agg-expr-lvalue.c
+++ b/clang/test/CIR/CodeGen/agg-expr-lvalue.c
@@ -27,8 +27,8 @@ void test_member_in_array(void) {
// LLVM-DAG: @[[MATRIX_CONST:.*]] = private constant [2 x [6 x i8]] {{.*}}
// CIR-LABEL: cir.func{{.*}} @test_member_in_array
-// CIR: %[[LINE:.*]] = cir.alloca "line" {{.*}} init !rec_Line
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>
+// CIR: %[[LINE:.*]] = cir.alloca "line" {{.*}} init : !cir.ptr<!rec_Line>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!rec_Point x 1>>
// CIR: cir.get_global @[[LINE_CONST]]
// CIR: cir.copy
// CIR: %[[MEMBER:.*]] = cir.get_member %[[LINE]][0] {name = "start"}
@@ -55,8 +55,8 @@ void test_member_arrow_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_member_arrow_in_array
-// CIR: %[[PTR:.*]] = cir.alloca "line_ptr" {{.*}} !cir.ptr<!rec_Line>
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>
+// CIR: %[[PTR:.*]] = cir.alloca "line_ptr" {{.*}} : !cir.ptr<!cir.ptr<!rec_Line>>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!rec_Point x 1>>
// CIR: %[[LOADED:.*]] = cir.load{{.*}}%[[PTR]]
// CIR: %[[MEMBER:.*]] = cir.get_member %[[LOADED]][0] {name = "start"}
// CIR: cir.copy
@@ -82,8 +82,8 @@ void test_deref_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_deref_in_array
-// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} !cir.ptr<!rec_Point>
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_Point x 1>
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} : !cir.ptr<!cir.ptr<!rec_Point>>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!rec_Point x 1>>
// CIR: %[[LOADED:.*]] = cir.load{{.*}}%[[PTR]]
// CIR: cir.copy
@@ -105,7 +105,7 @@ void test_string_array_in_array(void) {
}
// CIR-LABEL: cir.func{{.*}} @test_string_array_in_array
-// CIR: %[[MATRIX:.*]] = cir.alloca "matrix" {{.*}} init !cir.array<!cir.array<!s8i x 6> x 2>
+// CIR: %[[MATRIX:.*]] = cir.alloca "matrix" {{.*}} init : !cir.ptr<!cir.array<!cir.array<!s8i x 6> x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[MATRIX_CONST]] : !cir.ptr<!cir.array<!cir.array<!s8i x 6> x 2>>
// CIR: cir.copy %[[CONST]] to %[[MATRIX]]
diff --git a/clang/test/CIR/CodeGen/agg-init-constexpr.cpp b/clang/test/CIR/CodeGen/agg-init-constexpr.cpp
index 713f6cc481b60..7bf98318caad3 100644
--- a/clang/test/CIR/CodeGen/agg-init-constexpr.cpp
+++ b/clang/test/CIR/CodeGen/agg-init-constexpr.cpp
@@ -20,7 +20,7 @@ extern "C" void construct() {
}
// CIR-LABEL: construct()
-// CIR-NEXT: %[[WC_ALLOCA:.*]] = cir.alloca {{.*}} !rec_WithCtor
+// CIR-NEXT: %[[WC_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_WithCtor>
// CIR-NEXT: %[[CONST_VAL:.*]] = cir.const #cir.const_record<{#cir.int<4> : !s32i, #cir.int<10> : !s64i, #cir.const_record<{#cir.int<5> : !s32i}> : !rec_HasVal}>
// CIR-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[WC_ALLOCA]]
// CIR-NEXT: cir.store{{.*}}%[[CONST_VAL]], %[[BITCAST]]
diff --git a/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp b/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp
index 334e246ba5731..617c7ea59d084 100644
--- a/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp
+++ b/clang/test/CIR/CodeGen/amdgpu-call-addrspace-cast.cpp
@@ -28,7 +28,7 @@ void call_with_global_ptr() {
}
// CIR-LABEL: cir.func{{.*}} @_Z19call_with_local_ptrv()
-// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i, target_address_space(5)>
+// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!s32i, target_address_space(5)>
// CIR: %[[CAST:.*]] = cir.cast address_space %[[ALLOCA]] : !cir.ptr<!s32i, target_address_space(5)> -> !cir.ptr<!s32i>
// CIR: cir.call @_Z9takes_ptrPi(%[[CAST]])
diff --git a/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp b/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp
index 53a4ee3b8ef85..9ddeb56a5b717 100644
--- a/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp
+++ b/clang/test/CIR/CodeGen/amdgpu-stack-alloca-array-decay.cpp
@@ -18,8 +18,8 @@ void foo() {
}
// CIR-LABEL: cir.func{{.*}} @_Z3foov()
-// CIR: %[[FMT_RAW:.*]] = cir.alloca "fmt" {{.*}} !cir.array<!s8i x 6> -> !cir.ptr<!cir.array<!s8i x 6>, target_address_space(5)>
-// CIR-NEXT: %[[TMP_RAW:.*]] = cir.alloca "tmp" {{.*}} !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>, target_address_space(5)>
+// CIR: %[[FMT_RAW:.*]] = cir.alloca "fmt" {{.*}} : !cir.ptr<!cir.array<!s8i x 6>, target_address_space(5)>
+// CIR-NEXT: %[[TMP_RAW:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!cir.ptr<!s8i>, target_address_space(5)>
// CIR-DAG: %[[FMT:.*]] = cir.cast address_space %[[FMT_RAW]] : !cir.ptr<!cir.array<!s8i x 6>, target_address_space(5)> -> !cir.ptr<!cir.array<!s8i x 6>>
// CIR-DAG: %[[TMP:.*]] = cir.cast address_space %[[TMP_RAW]] : !cir.ptr<!cir.ptr<!s8i>, target_address_space(5)> -> !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[FMT]] : !cir.ptr<!cir.array<!s8i x 6>> -> !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/array-ctor.cpp b/clang/test/CIR/CodeGen/array-ctor.cpp
index fcdfdb75537c4..f9bddfdc72c8e 100644
--- a/clang/test/CIR/CodeGen/array-ctor.cpp
+++ b/clang/test/CIR/CodeGen/array-ctor.cpp
@@ -15,7 +15,7 @@ void foo() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z3foov()
-// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.array<!rec_S x 42>>
// CIR-BEFORE-LPP: cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 42>> {
// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -24,11 +24,11 @@ void foo() {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z3foov()
-// CIR: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+// CIR: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.array<!rec_S x 42>>
// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 42>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST42]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[DECAY]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
@@ -84,12 +84,12 @@ void zero_sized() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z10zero_sizedv()
-// CIR-BEFORE-LPP: cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
+// CIR-BEFORE-LPP: cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-BEFORE-LPP-NOT: cir.array.ctor
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func {{.*}} @_Z10zero_sizedv()
-// CIR: cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
+// CIR: cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-NOT: cir.do
// CIR-NOT: cir.call @_ZN1SC1Ev
// CIR: cir.return
@@ -109,7 +109,7 @@ void multi_dimensional() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} init !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR-BEFORE-LPP: %[[FLAT:.*]] = cir.cast bitcast %[[S]] : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>> -> !cir.ptr<!cir.array<!rec_S x 15>>
// CIR-BEFORE-LPP: cir.array.ctor %[[FLAT]] : !cir.ptr<!cir.array<!rec_S x 15>> {
// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
@@ -118,11 +118,11 @@ void multi_dimensional() {
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR: %[[CONST15:.*]] = cir.const #cir.int<15> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay {{.*}} : !cir.ptr<!cir.array<!rec_S x 15>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST15]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[DECAY]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/array-dtor.cpp b/clang/test/CIR/CodeGen/array-dtor.cpp
index b52e41cd8acdb..11e685c92514f 100644
--- a/clang/test/CIR/CodeGen/array-dtor.cpp
+++ b/clang/test/CIR/CodeGen/array-dtor.cpp
@@ -15,7 +15,7 @@ void test_cleanup_array() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z18test_cleanup_arrayv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!rec_S x 42>>
// CIR-BEFORE-LPP: cir.array.dtor %[[S]] : !cir.ptr<!cir.array<!rec_S x 42>> {
// CIR-BEFORE-LPP: ^bb0(%arg0: !cir.ptr<!rec_S>
// CIR-BEFORE-LPP: cir.call @_ZN1SD1Ev(%arg0) nothrow : (!cir.ptr<!rec_S> {{.*}}) -> ()
@@ -23,11 +23,11 @@ void test_cleanup_array() {
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z18test_cleanup_arrayv()
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!rec_S x 42>>
// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[S]] : !cir.ptr<!cir.array<!rec_S x 42>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST42]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[END_PTR]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
@@ -82,12 +82,12 @@ void test_cleanup_zero_length_array() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z30test_cleanup_zero_length_arrayv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-BEFORE-LPP-NOT: cir.array.dtor
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z30test_cleanup_zero_length_arrayv()
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!rec_S x 0> -> !cir.ptr<!cir.array<!rec_S x 0>>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!rec_S x 0>>
// CIR-NOT: cir.do
// CIR-NOT: cir.call @_ZN1SD1Ev
// CIR: cir.return
@@ -107,7 +107,7 @@ void multi_dimensional() {
}
// CIR-BEFORE-LPP: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
+// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR-BEFORE-LPP: %[[FLAT:.*]] = cir.cast bitcast %[[S]] : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>> -> !cir.ptr<!cir.array<!rec_S x 15>>
// CIR-BEFORE-LPP: cir.array.dtor %[[FLAT]] : !cir.ptr<!cir.array<!rec_S x 15>> {
// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
@@ -116,12 +116,12 @@ void multi_dimensional() {
// CIR-BEFORE-LPP: cir.return
// CIR: cir.func{{.*}} @_Z17multi_dimensionalv()
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !cir.array<!cir.array<!rec_S x 5> x 3> -> !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>>
// CIR: %[[FLAT:.*]] = cir.cast bitcast %[[S]] : !cir.ptr<!cir.array<!cir.array<!rec_S x 5> x 3>> -> !cir.ptr<!cir.array<!rec_S x 15>>
// CIR: %[[CONST15:.*]] = cir.const #cir.int<15> : !u64i
// CIR: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[FLAT]] : !cir.ptr<!cir.array<!rec_S x 15>> -> !cir.ptr<!rec_S>
// CIR: %[[END_PTR:.*]] = cir.ptr_stride %[[DECAY]], %[[CONST15]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[END_PTR]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp b/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp
index 48b478da06840..b8fc4b17ea38d 100644
--- a/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp
+++ b/clang/test/CIR/CodeGen/array-init-loop-exprs.cpp
@@ -18,9 +18,9 @@ struct HasNonTrivialArray {
};
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN18HasNonTrivialArrayC2ERKS_({{.*}}) special_member<#cir.cxx_ctor<!rec_HasNonTrivialArray, copy>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasNonTrivialArray> -> !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>
-// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_HasNonTrivialArray> -> !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>
-// CIR: %[[ITR_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_NonTrivial> -> !cir.ptr<!cir.ptr<!rec_NonTrivial>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>
+// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>
+// CIR: %[[ITR_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_NonTrivial>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>, !cir.ptr<!rec_HasNonTrivialArray>
// CIR: %[[THIS_ARR:.*]] = cir.get_member %[[THIS_LOAD]][0] {name = "arr"} : !cir.ptr<!rec_HasNonTrivialArray> -> !cir.ptr<!cir.array<!rec_NonTrivial x 3>>
// CIR: %[[RHS_LOAD:.*]] = cir.load %[[RHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasNonTrivialArray>>, !cir.ptr<!rec_HasNonTrivialArray>
@@ -138,11 +138,11 @@ struct HasMultiDimArray {
};
// CIR-LABEL: cir.func {{.*}}@_ZN16HasMultiDimArrayC2ERKS_({{.*}}) special_member<#cir.cxx_ctor<!rec_HasMultiDimArray, copy>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasMultiDimArray> -> !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>
-// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_HasMultiDimArray> -> !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>
-// CIR: %[[ITR1_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>>>
-// CIR: %[[ITR2_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!cir.array<!rec_NonTrivial x 4>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NonTrivial x 4>>>
-// CIR: %[[ITR3_ALLOCA:.*]] = cir.alloca "arrayinit.temp" align(8) !cir.ptr<!rec_NonTrivial> -> !cir.ptr<!cir.ptr<!rec_NonTrivial>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>
+// CIR: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>
+// CIR: %[[ITR1_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3>>>
+// CIR: %[[ITR2_ALLOCA:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!cir.array<!rec_NonTrivial x 4>>>
+// CIR: %[[ITR3_ALLOCA:.*]] = cir.alloca "arrayinit.temp" align(8) : !cir.ptr<!cir.ptr<!rec_NonTrivial>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>, !cir.ptr<!rec_HasMultiDimArray>
// CIR: %[[THIS_ARR:.*]] = cir.get_member %[[THIS_LOAD]][0] {name = "arr"} : !cir.ptr<!rec_HasMultiDimArray> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NonTrivial x 4> x 3> x 2>>
// CIR: %[[RHS_LOAD:.*]] = cir.load %[[RHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMultiDimArray>>, !cir.ptr<!rec_HasMultiDimArray>
diff --git a/clang/test/CIR/CodeGen/array.cpp b/clang/test/CIR/CodeGen/array.cpp
index e673dcf743ef9..5d288ad91a576 100644
--- a/clang/test/CIR/CodeGen/array.cpp
+++ b/clang/test/CIR/CodeGen/array.cpp
@@ -144,9 +144,9 @@ void func() {
int e2 = arr[1];
}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[INIT_2:.*]] = cir.alloca "e2" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} : !cir.ptr<!cir.array<!s32i x 10>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[INIT_2:.*]] = cir.alloca "e2" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[ELE_PTR:.*]] = cir.get_element %[[ARR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[ELE_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -181,7 +181,7 @@ void func2() {
int arr[2] = {5};
}
-// CIR: %[[ARR2:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[ARR2:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC2_ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR2]] : !cir.ptr<!cir.array<!s32i x 2>>
@@ -199,9 +199,9 @@ void func3() {
int e = arr[idx];
}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
-// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC3_ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[IDX_V:.*]] = cir.const #cir.int<1> : !s32i
@@ -240,8 +240,8 @@ void func4() {
int e = arr[1][0];
}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.array<!s32i x 1> x 2> -> !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC4_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
@@ -272,7 +272,7 @@ void func5() {
int arr[2][1] = {{5}};
}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.array<!s32i x 1> x 2> -> !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC5_ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.array<!s32i x 1> x 2>>
@@ -288,8 +288,8 @@ void func6() {
int arr[2] = { x, 5 };
}
-// CIR: %[[VAR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[VAR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[V:.*]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store{{.*}} %[[V]], %[[VAR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[ARR_PTR:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
@@ -322,7 +322,7 @@ void func7() {
int* arr[1] = {};
}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.ptr<!s32i> x 1> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
// CIR: %[[CONST:.*]] = cir.get_global @[[FUNC7_ARR]] : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
// CIR: cir.copy %[[CONST]] to %[[ARR]] : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 1>>
@@ -339,9 +339,9 @@ void func8(int arr[10]) {
}
// CIR: cir.func{{.*}} @_Z5func8Pi(%[[ARG:.*]]: !cir.ptr<!s32i>
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[INIT_2:.*]] = cir.alloca "e2" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[INIT_2:.*]] = cir.alloca "e2" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -386,8 +386,8 @@ void func9(int arr[10][5]) {
}
// CIR: cir.func{{.*}} @_Z5func9PA5_i(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!cir.array<!s32i x 5>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<2> : !s64i
// CIR: %[[IDX_1:.*]] = cir.const #cir.int<1> : !s64i
@@ -421,8 +421,8 @@ void func10(int *a) {
}
// CIR: cir.func{{.*}} @_Z6func10Pi(%[[ARG:.*]]: !cir.ptr<!s32i>
-// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG]], %[[ARR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<5> : !s64i
// CIR: %[[TMP_1:.*]] = cir.load{{.*}} %[[ARR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -449,7 +449,7 @@ void func10(int *a) {
void func11() { int _Complex a[4]; }
-// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} !cir.array<!cir.complex<!s32i> x 4> -> !cir.ptr<!cir.array<!cir.complex<!s32i> x 4>>
+// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.array<!cir.complex<!s32i> x 4>>
// LLVM: %[[ARR:.*]] = alloca [4 x { i32, i32 }], i64 1, align 16
@@ -464,7 +464,7 @@ void func12() {
Point a[4];
}
-// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} !cir.array<!rec_Point x 4> -> !cir.ptr<!cir.array<!rec_Point x 4>>
+// CIR: %[[ARR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.array<!rec_Point x 4>>
// LLVM: %[[ARR:.*]] = alloca [4 x %struct.Point], i64 1, align 16
@@ -474,7 +474,7 @@ void array_with_complex_elements() {
_Complex float arr[2] = {{1.1f, 2.2f}, {3.3f, 4.4f}};
}
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!cir.complex<!cir.float> x 2> -> !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
// CIR: %[[CONST:.*]] = cir.get_global @[[COMPLEX_ARR]] : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
// CIR: cir.copy %[[CONST]] to %[[ARR_ADDR]] : !cir.ptr<!cir.array<!cir.complex<!cir.float> x 2>>
@@ -489,9 +489,9 @@ void boolean_index_access(int x) {
int n = arr[x > 4];
}
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR: %[[CMP:.*]] = cir.cmp gt %[[X]], %[[FOUR]] : !s32i
@@ -529,9 +529,9 @@ void bitint_index_access(_BitInt(7) i) {
// being used as a subscript.
// CIR: cir.func{{.*}} @_Z19bitint_index_accessDB7_
-// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !cir.int<s, 7, bitint> -> !cir.ptr<!cir.int<s, 7, bitint>>
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!cir.int<s, 7, bitint>>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 10>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[I:.*]] = cir.load{{.*}} %[[I_ADDR]] : !cir.ptr<!cir.int<s, 7, bitint>>, !cir.int<s, 7, bitint>
// CIR: %[[IDX:.*]] = cir.cast integral %[[I]] : !cir.int<s, 7, bitint> -> !s64i
// CIR: %[[ELE:.*]] = cir.get_element %[[ARR_ADDR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/assign-operator.cpp b/clang/test/CIR/CodeGen/assign-operator.cpp
index bf88e8ff0a269..d8564d6d21743 100644
--- a/clang/test/CIR/CodeGen/assign-operator.cpp
+++ b/clang/test/CIR/CodeGen/assign-operator.cpp
@@ -15,7 +15,7 @@ void a() {
// CIR: cir.func {{.*}} @_ZN1xaSEi(!cir.ptr<!rec_x> {{.*}}, !s32i {{.*}})
// CIR: cir.func{{.*}} @_Z1av()
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_x -> !cir.ptr<!rec_x>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_x>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[RET:.*]] = cir.call @_ZN1xaSEi(%[[A_ADDR]], %[[ONE]]) : (!cir.ptr<!rec_x> {{.*}}, !s32i {{.*}}) -> (!s32i {llvm.noundef})
@@ -27,8 +27,8 @@ void f(int i, int j) {
}
// CIR: cir.func{{.*}} @_Z1fii(%arg0: !s32i {{.*}}, %arg1: !s32i {{.*}})
-// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[J_ADDR:.*]] = cir.alloca "j" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[J_ADDR:.*]] = cir.alloca "j" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store %arg0, %[[I_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %arg1, %[[J_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[SEVENTEEN:.*]] = cir.const #cir.int<17> : !s32i
@@ -63,9 +63,9 @@ void copy_c(C &c1, C &c2) {
// Implicit assignment operator for C.
// CIR: cir.func {{.*}} @_ZN1CaSERKS_(%arg0: !cir.ptr<!rec_C> {{.*}}, %arg1: !cir.ptr<!rec_C> {{.*}}) -> (!cir.ptr<!rec_C>{{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
-// CIR: %[[ARG1_ADDR:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[ARG1_ADDR:.*]] = cir.alloca "" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: cir.store %arg0, %[[THIS_ADDR]]
// CIR: cir.store %arg1, %[[ARG1_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
@@ -111,8 +111,8 @@ void copy_c(C &c1, C &c2) {
// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}} %[[B1]], ptr {{.*}} %[[B2]], i64 64, i1 false)
// CIR: cir.func{{.*}} @_Z6copy_cR1CS0_(%arg0: !cir.ptr<!rec_C> {{.*}}, %arg1: !cir.ptr<!rec_C> {{.*}})
-// CIR: %[[C1_ADDR:.*]] = cir.alloca "c1" {{.*}} init const !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
-// CIR: %[[C2_ADDR:.*]] = cir.alloca "c2" {{.*}} init const !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[C1_ADDR:.*]] = cir.alloca "c1" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[C2_ADDR:.*]] = cir.alloca "c2" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: cir.store %arg0, %[[C1_ADDR]]
// CIR: cir.store %arg1, %[[C2_ADDR]]
// CIR: %[[C2_LOAD:.*]] = cir.load{{.*}} %[[C2_ADDR]]
@@ -135,8 +135,8 @@ void copy_ref_to_ref(E &e1, E &e2) {
// The call to e2.get_d_ref() must occur before the call to e1.get_d_ref().
// CIR: cir.func{{.*}} @_Z15copy_ref_to_refR1ES0_(%arg0: !cir.ptr<!rec_E> {{.*}}, %arg1: !cir.ptr<!rec_E> {{.*}})
-// CIR: %[[E1_ADDR:.*]] = cir.alloca "e1" {{.*}} init const !cir.ptr<!rec_E> -> !cir.ptr<!cir.ptr<!rec_E>>
-// CIR: %[[E2_ADDR:.*]] = cir.alloca "e2" {{.*}} init const !cir.ptr<!rec_E> -> !cir.ptr<!cir.ptr<!rec_E>>
+// CIR: %[[E1_ADDR:.*]] = cir.alloca "e1" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_E>>
+// CIR: %[[E2_ADDR:.*]] = cir.alloca "e2" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_E>>
// CIR: cir.store %arg0, %[[E1_ADDR]] : !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>
// CIR: cir.store %arg1, %[[E2_ADDR]] : !cir.ptr<!rec_E>, !cir.ptr<!cir.ptr<!rec_E>>
// CIR: %[[E2:.*]] = cir.load %[[E2_ADDR]]
diff --git a/clang/test/CIR/CodeGen/assume-attr.cpp b/clang/test/CIR/CodeGen/assume-attr.cpp
index 0e166b925c105..a3ea3bb6faaf6 100644
--- a/clang/test/CIR/CodeGen/assume-attr.cpp
+++ b/clang/test/CIR/CodeGen/assume-attr.cpp
@@ -16,9 +16,9 @@ void usage(int i, int j) {
// CIR: cir.func{{.*}}@_Z5usageii
// BOTH: define{{.*}}@_Z5usageii
- // CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[J:.*]] = cir.alloca "j" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} init const !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[J:.*]] = cir.alloca "j" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} init const : !cir.ptr<!s32i>
//
// BOTH: %[[I:.*]] = alloca i32
// BOTH: %[[J:.*]] = alloca i32
diff --git a/clang/test/CIR/CodeGen/atomic-thread-fence.c b/clang/test/CIR/CodeGen/atomic-thread-fence.c
index 00b4820ed061d..594bf978cabcb 100644
--- a/clang/test/CIR/CodeGen/atomic-thread-fence.c
+++ b/clang/test/CIR/CodeGen/atomic-thread-fence.c
@@ -46,7 +46,7 @@ void modifyWithThreadFence(DataPtr d) {
__atomic_thread_fence(__ATOMIC_SEQ_CST);
d->value = 42;
// CIR-LABEL: @modifyWithThreadFence
- // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init : !cir.ptr<!cir.ptr<!rec_Data>>
// CIR: cir.atomic.fence syncscope(system) seq_cst
// CIR: %[[VAL_42:.*]] = cir.const #cir.int<42> : !s32i
// CIR: %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
@@ -75,7 +75,7 @@ void modifyWithSignalFence(DataPtr d) {
__atomic_signal_fence(__ATOMIC_SEQ_CST);
d->value = 24;
// CIR-LABEL: @modifyWithSignalFence
- // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init : !cir.ptr<!cir.ptr<!rec_Data>>
// CIR: cir.atomic.fence syncscope(single_thread) seq_cst
// CIR: %[[VAL_42:.*]] = cir.const #cir.int<24> : !s32i
// CIR: %[[LOAD_DATA:.*]] = cir.load{{.*}} %[[DATA]] : !cir.ptr<!cir.ptr<!rec_Data>>, !cir.ptr<!rec_Data>
@@ -104,8 +104,8 @@ void loadWithThreadFence(DataPtr d) {
__atomic_thread_fence(__ATOMIC_SEQ_CST);
__atomic_load_n(&d->ptr, __ATOMIC_SEQ_CST);
// CIR-LABEL: @loadWithThreadFence
- // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init : !cir.ptr<!cir.ptr<!rec_Data>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) : !cir.ptr<!cir.ptr<!void>>
// 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>>
@@ -141,8 +141,8 @@ void loadWithSignalFence(DataPtr d) {
__atomic_signal_fence(__ATOMIC_SEQ_CST);
__atomic_load_n(&d->ptr, __ATOMIC_SEQ_CST);
// CIR-LABEL: @loadWithSignalFence
- // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init !cir.ptr<!rec_Data> -> !cir.ptr<!cir.ptr<!rec_Data>>
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[DATA:.*]] = cir.alloca "d" align(8) init : !cir.ptr<!cir.ptr<!rec_Data>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) : !cir.ptr<!cir.ptr<!void>>
// 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>>
diff --git a/clang/test/CIR/CodeGen/atomic.c b/clang/test/CIR/CodeGen/atomic.c
index f3190c248a0d2..48beeb1ec1136 100644
--- a/clang/test/CIR/CodeGen/atomic.c
+++ b/clang/test/CIR/CodeGen/atomic.c
@@ -21,7 +21,7 @@ void f1(void) {
}
// CIR-LABEL: @f1
-// CIR: %[[SLOT:.+]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SLOT:.+]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[INIT:.+]] = cir.const #cir.int<42> : !s32i
// CIR-NEXT: cir.store align(4) %[[INIT]], %[[SLOT]] : !s32i, !cir.ptr<!s32i>
// CIR: }
@@ -42,7 +42,7 @@ void f2(void) {
}
// CIR-LABEL: @f2
-// CIR: %[[SLOT:.+]] = cir.alloca "x" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR: %[[SLOT:.+]] = cir.alloca "x" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[INIT:.+]] = cir.const #cir.int<42> : !s32i
// CIR-NEXT: cir.store align(4) %[[INIT]], %[[SLOT]] : !s32i, !cir.ptr<!s32i>
// CIR: }
@@ -288,7 +288,7 @@ void c11_atomic_cmpxchg_strong(_Atomic(int) *ptr, int *expected, int desired, in
// CIR-LABEL: @c11_atomic_cmpxchg_strong
// LLVM-LABEL: @c11_atomic_cmpxchg_strong
// OGCG-LABEL: @c11_atomic_cmpxchg_strong
- // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init : !cir.ptr<!s32i>
__c11_atomic_compare_exchange_strong(ptr, expected, desired,
__ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
@@ -370,7 +370,7 @@ void c11_atomic_cmpxchg_weak(_Atomic(int) *ptr, int *expected, int desired, int
// CIR-LABEL: @c11_atomic_cmpxchg_weak
// LLVM-LABEL: @c11_atomic_cmpxchg_weak
// OGCG-LABEL: @c11_atomic_cmpxchg_weak
- // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init : !cir.ptr<!s32i>
__c11_atomic_compare_exchange_weak(ptr, expected, desired,
__ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
@@ -452,7 +452,7 @@ void atomic_cmpxchg(int *ptr, int *expected, int *desired, int failure) {
// CIR-LABEL: @atomic_cmpxchg
// LLVM-LABEL: @atomic_cmpxchg
// OGCG-LABEL: @atomic_cmpxchg
- // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init : !cir.ptr<!s32i>
__atomic_compare_exchange(ptr, expected, desired, /*weak=*/0, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[OLD:.+]], %[[SUCCESS:.+]] = cir.atomic.cmpxchg success(seq_cst) failure(acquire) syncscope(system) %{{.+}}, %{{.+}}, %{{.+}} align(4) : (!cir.ptr<!s32i>, !s32i, !s32i) -> (!s32i, !cir.bool)
@@ -633,7 +633,7 @@ void atomic_cmpxchg_n(int *ptr, int *expected, int desired, int failure) {
// CIR-LABEL: @atomic_cmpxchg_n
// LLVM-LABEL: @atomic_cmpxchg_n
// OGCG-LABEL: @atomic_cmpxchg_n
- // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init : !cir.ptr<!s32i>
__atomic_compare_exchange_n(ptr, expected, desired, /*weak=*/0, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[OLD:.+]], %[[SUCCESS:.+]] = cir.atomic.cmpxchg success(seq_cst) failure(acquire) syncscope(system) %{{.+}}, %{{.+}}, %{{.+}} align(4) : (!cir.ptr<!s32i>, !s32i, !s32i) -> (!s32i, !cir.bool)
@@ -956,8 +956,8 @@ float *atomic_fetch_ptr_to_ptr(float **ptr, int value) {
// OGCG-LABEL: @atomic_fetch_ptr_to_ptr
return __atomic_fetch_add(ptr, value, __ATOMIC_SEQ_CST);
- // CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!cir.float> -> !cir.ptr<!cir.ptr<!cir.float>>
+ // CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) : !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_LOAD:.*]] = cir.load align(8) %[[PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>, !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_CAST:.*]] = cir.cast bitcast %[[PTR_LOAD]] : !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!s64i>
// CIR: %[[RESULT:.*]] = cir.atomic.fetch add seq_cst syncscope(system) fetch_first %[[PTR_CAST]], %{{.*}} : (!cir.ptr<!s64i>, !s64i) -> !s64i
@@ -976,8 +976,8 @@ float *atomic_fetch_ptr_to_ptr2(float **ptr, int value) {
// LLVM-LABEL: @atomic_fetch_ptr_to_ptr2
// OGCG-LABEL: @atomic_fetch_ptr_to_ptr2
return __atomic_add_fetch(ptr, value, __ATOMIC_SEQ_CST);
- // CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>
- // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) !cir.ptr<!cir.float> -> !cir.ptr<!cir.ptr<!cir.float>>
+ // CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>
+ // CIR: %[[ATOMIC_TEMP:.*]] = cir.alloca "atomic-temp" align(8) : !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_LOAD:.*]] = cir.load align(8) %[[PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.float>>>, !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[PTR_CAST:.*]] = cir.cast bitcast %[[PTR_LOAD]] : !cir.ptr<!cir.ptr<!cir.float>> -> !cir.ptr<!s64i>
// CIR: %[[RESULT:.*]] = cir.atomic.fetch add seq_cst syncscope(system) %[[PTR_CAST]], %{{.*}} : (!cir.ptr<!s64i>, !s64i) -> !s64i
@@ -3281,8 +3281,8 @@ void atomic_cmpxchg_maybe_weak(int *ptr, int *expected, int *desired, int failur
// CIR-LABEL: @atomic_cmpxchg_maybe_weak
// LLVM-LABEL: @atomic_cmpxchg_maybe_weak
// OGCG-LABEL: @atomic_cmpxchg_maybe_weak
- // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[WEAK:.*]] = cir.alloca "weak" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[WEAK:.*]] = cir.alloca "weak" {{.*}} init : !cir.ptr<!s32i>
__atomic_compare_exchange(ptr, expected, desired, weak, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[WEAK_LOAD:.*]] = cir.load{{.*}}%[[WEAK]]
@@ -3459,8 +3459,8 @@ void atomic_cmpxchg_n_maybe_weak(int *ptr, int *expected, int desired, int failu
// CIR-LABEL: @atomic_cmpxchg_n_maybe_weak
// LLVM-LABEL: @atomic_cmpxchg_n_maybe_weak
// OGCG-LABEL: @atomic_cmpxchg_n_maybe_weak
- // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[WEAK:.*]] = cir.alloca "weak" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[FAILURE:.*]] = cir.alloca "failure" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[WEAK:.*]] = cir.alloca "weak" {{.*}} init : !cir.ptr<!s32i>
__atomic_compare_exchange_n(ptr, expected, desired, weak, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE);
// CIR: %[[WEAK_LOAD:.*]] = cir.load{{.*}}%[[WEAK]]
diff --git a/clang/test/CIR/CodeGen/base-to-derived.cpp b/clang/test/CIR/CodeGen/base-to-derived.cpp
index 067aef7ce6d59..6d4e5b735c68b 100644
--- a/clang/test/CIR/CodeGen/base-to-derived.cpp
+++ b/clang/test/CIR/CodeGen/base-to-derived.cpp
@@ -24,7 +24,7 @@ X *castAtoX(A *a) {
}
// CIR: cir.func {{.*}} @_Z8castAtoXP1A(%[[ARG0:.*]]: !cir.ptr<!rec_A> {{.*}})
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!rec_A>>
// CIR: cir.store %[[ARG0]], %[[A_ADDR]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[X:.*]] = cir.derived_class_addr %[[A]] : !cir.ptr<!rec_A> [0] -> !cir.ptr<!rec_X>
@@ -46,7 +46,7 @@ X *castBtoX(B *b) {
}
// CIR: cir.func {{.*}} @_Z8castBtoXP1B(%[[ARG0:.*]]: !cir.ptr<!rec_B> {{.*}})
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.ptr<!rec_B>>
// CIR: cir.store %[[ARG0]], %[[B_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] : !cir.ptr<!rec_B> [4] -> !cir.ptr<!rec_X>
@@ -79,7 +79,7 @@ X &castBReftoXRef(B &b) {
}
// CIR: cir.func {{.*}} @_Z14castBReftoXRefR1B(%[[ARG0:.*]]: !cir.ptr<!rec_B> {{.*}})
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init const !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_B>>
// CIR: cir.store %[[ARG0]], %[[B_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] : !cir.ptr<!rec_B> nonnull [4] -> !cir.ptr<!rec_X>
diff --git a/clang/test/CIR/CodeGen/basic.c b/clang/test/CIR/CodeGen/basic.c
index 01482cc952558..af838baf0ee13 100644
--- a/clang/test/CIR/CodeGen/basic.c
+++ b/clang/test/CIR/CodeGen/basic.c
@@ -35,8 +35,8 @@ int f1(int i) {
}
// CIR: cir.func{{.*}} @f1(%arg0: !s32i {llvm.noundef} loc({{.*}})) -> !s32i
-// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %arg0, %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: %[[I_IGNORED:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -65,7 +65,7 @@ int f1(int i) {
int f2(void) { return 3; }
// CIR: cir.func{{.*}} @f2() -> !s32i
-// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[THREE]], %[[RV]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: %[[R:.*]] = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
@@ -87,8 +87,8 @@ int f3(void) {
}
// CIR: cir.func{{.*}} @f3() -> !s32i
-// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[I_PTR:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[THREE]], %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -172,7 +172,7 @@ int f6(void) {
}
// CIR: cir.func{{.*}} @f6() -> !s32i
-// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[GV_PTR:.*]] = cir.get_global @gv : !cir.ptr<!s32i>
// CIR-NEXT: %[[GV:.*]] = cir.load{{.*}} %[[GV_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: cir.store{{.*}} %[[GV]], %[[RV]] : !s32i, !cir.ptr<!s32i>
@@ -196,9 +196,9 @@ int f7(int a, int b, int c) {
}
// CIR: cir.func{{.*}} @f7
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[C_PTR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[C_PTR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[C:.*]] = cir.load{{.*}} %[[C_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -232,7 +232,7 @@ int f8(int *p) {
}
// CIR: cir.func{{.*}} @f8
-// CIR: %[[P_PTR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[P_PTR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: %[[P:.*]] = cir.load deref{{.*}} %[[P_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[TWO]], %[[P]] : !s32i, !cir.ptr<!s32i>
@@ -270,7 +270,7 @@ void f9() {}
void f10(int arg0, ...) {}
// CIR: cir.func{{.*}} @f10(%[[ARG0:.*]]: !s32i {llvm.noundef} loc({{.*}}), ...)
-// CIR-NEXT: %[[ARG0_PTR:.*]] = cir.alloca "arg0" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[ARG0_PTR:.*]] = cir.alloca "arg0" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[ARG0]], %[[ARG0_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.return
diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp
index f92fcb26e13e2..6a31e07a38285 100644
--- a/clang/test/CIR/CodeGen/basic.cpp
+++ b/clang/test/CIR/CodeGen/basic.cpp
@@ -32,8 +32,8 @@ int f1() {
}
// CHECK: cir.func{{.*}} @_Z2f1v() -> (!s32i {{.*}})
-// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[I_PTR:.*]] = cir.alloca "i" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CHECK: %[[I_PTR:.*]] = cir.alloca "i" align(4) : !cir.ptr<!s32i>
// CHECK: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
// CHECK: cir.store{{.*}} %[[I]], %[[RV]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[R:.*]] = cir.load{{.*}} %[[RV]] : !cir.ptr<!s32i>, !s32i
@@ -45,8 +45,8 @@ int f2() {
}
// CHECK: cir.func{{.*}} @_Z2f2v() -> (!s32i {{.*}})
-// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[I_PTR:.*]] = cir.alloca "i" align(4) init const !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CHECK: %[[I_PTR:.*]] = cir.alloca "i" align(4) init const : !cir.ptr<!s32i>
// CHECK: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CHECK: cir.store{{.*}} %[[TWO]], %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[I:.*]] = cir.load{{.*}} %[[I_PTR]] : !cir.ptr<!s32i>, !s32i
@@ -59,8 +59,8 @@ int f3(int i) {
}
// CHECK: cir.func{{.*}} @_Z2f3i(%[[ARG:.*]]: !s32i {{.*}} loc({{.*}})) -> (!s32i {{.*}})
-// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CHECK: cir.store{{.*}} %[[ARG]], %[[ARG_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[ARG_VAL:.*]] = cir.load{{.*}} %[[ARG_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CHECK: cir.store{{.*}} %[[ARG_VAL]], %[[RV]] : !s32i, !cir.ptr<!s32i>
@@ -72,8 +72,8 @@ int f4(const int i) {
}
// CHECK: cir.func{{.*}} @_Z2f4i(%[[ARG:.*]]: !s32i {{.*}} loc({{.*}})) -> (!s32i {{.*}})
-// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init const !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init const : !cir.ptr<!s32i>
+// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CHECK: cir.store{{.*}} %[[ARG]], %[[ARG_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[ARG_VAL:.*]] = cir.load{{.*}} %[[ARG_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CHECK: cir.store{{.*}} %[[ARG_VAL]], %[[RV]] : !s32i, !cir.ptr<!s32i>
@@ -92,12 +92,12 @@ int *f5() {
}
// CHECK: cir.func{{.*}} @_Z2f5v() -> (!cir.ptr<!s32i> {{.*}})
-// CHECK-NEXT: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CHECK-NEXT: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: %[[NULLPTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store{{.*}} %[[NULLPTR]], %[[P_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[X_ADDR:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[X_ADDR:.*]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[X_ADDR]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store{{.*}} %[[X_ADDR]], %[[P_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -131,8 +131,8 @@ void ref_arg(int &x) {
}
// CHECK: cir.func{{.*}} @_Z7ref_argRi(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}})
-// CHECK: %[[X_REF_ADDR:.*]] = cir.alloca "x" align(8) init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %[[Y_ADDR:.*]] = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[X_REF_ADDR:.*]] = cir.alloca "x" align(8) init const : !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[Y_ADDR:.*]] = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
// CHECK: cir.store{{.*}} %[[ARG]], %[[X_REF_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK: %[[X_REF:.*]] = cir.load{{.*}} %[[X_REF_ADDR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CHECK: %[[Y:.*]] = cir.load{{.*}} %[[X_REF]] : !cir.ptr<!s32i>, !s32i
@@ -148,7 +148,7 @@ short &return_ref() {
}
// CHECK: cir.func{{.*}} @_Z10return_refv() -> (!cir.ptr<!s16i> {{.*}})
-// CHECK: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
+// CHECK: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!s16i>>
// CHECK: %[[GS_ADDR:.*]] = cir.get_global @gs : !cir.ptr<!s16i>
// CHECK: cir.store{{.*}} %[[GS_ADDR]], %[[RETVAL_ADDR]] : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
// CHECK: %[[RETVAL:.*]] = cir.load{{.*}} %[[RETVAL_ADDR]] : !cir.ptr<!cir.ptr<!s16i>>, !cir.ptr<!s16i>
@@ -159,7 +159,7 @@ void ref_local(short x) {
}
// CHECK: cir.func{{.*}} @_Z9ref_locals(%[[ARG:.*]]: !s16i {{.*}})
-// CHECK: %[[X_ADDR:.*]] = cir.alloca "x" align(2) init !s16i -> !cir.ptr<!s16i>
-// CHECK: %[[Y_REF_ADDR:.*]] = cir.alloca "y" align(8) init const !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
+// CHECK: %[[X_ADDR:.*]] = cir.alloca "x" align(2) init : !cir.ptr<!s16i>
+// CHECK: %[[Y_REF_ADDR:.*]] = cir.alloca "y" align(8) init const : !cir.ptr<!cir.ptr<!s16i>>
// CHECK: cir.store{{.*}} %[[ARG]], %[[X_ADDR]] : !s16i, !cir.ptr<!s16i>
// CHECK: cir.store{{.*}} %[[X_ADDR]], %[[Y_REF_ADDR]] : !cir.ptr<!s16i>, !cir.ptr<!cir.ptr<!s16i>>
diff --git a/clang/test/CIR/CodeGen/binassign.c b/clang/test/CIR/CodeGen/binassign.c
index 8dd3985496b18..b650211646623 100644
--- a/clang/test/CIR/CodeGen/binassign.c
+++ b/clang/test/CIR/CodeGen/binassign.c
@@ -18,10 +18,10 @@ void binary_assign(void) {
}
// CIR-LABEL: cir.func{{.*}} @binary_assign()
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} !s8i -> !cir.ptr<!s8i>
-// CIR: %[[F:.*]] = cir.alloca "f" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!s8i>
+// CIR: %[[F:.*]] = cir.alloca "f" {{.*}} : !cir.ptr<!cir.float>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store{{.*}} %[[TRUE]], %[[B]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
@@ -78,8 +78,8 @@ void binary_assign_struct() {
}
// CIR: cir.func{{.*}} @binary_assign_struct()
-// CIR: %[[LS:.*]] = cir.alloca "ls" {{.*}} ![[REC_S:.*]] -> !cir.ptr<![[REC_S]]>
-// CIR: %[[LSV:.*]] = cir.alloca "lsv" {{.*}} ![[REC_SV:.*]] -> !cir.ptr<![[REC_SV]]>
+// CIR: %[[LS:.*]] = cir.alloca "ls" {{.*}} : !cir.ptr<![[REC_S:.*]]>
+// CIR: %[[LSV:.*]] = cir.alloca "lsv" {{.*}} : !cir.ptr<![[REC_SV:.*]]>
// CIR: %[[GS_PTR:.*]] = cir.get_global @gs : !cir.ptr<![[REC_S]]>
// CIR: cir.copy %[[GS_PTR]] to %[[LS]] : !cir.ptr<![[REC_S]]>
// CIR: %[[GSV_PTR:.*]] = cir.get_global @gsv : !cir.ptr<![[REC_SV]]>
@@ -112,12 +112,12 @@ int ignore_result_assign() {
}
// CIR-LABEL: cir.func{{.*}} @ignore_result_assign() -> !s32i
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[J:.*]] = cir.alloca "j" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[Q:.*]] = cir.alloca "q" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} : !cir.ptr<!cir.array<!s32i x 10>>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[J:.*]] = cir.alloca "j" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[Q:.*]] = cir.alloca "q" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[VAL_123:.*]] = cir.const #cir.int<123> : !s32i
// CIR: cir.store{{.*}} %[[VAL_123]], %[[I]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[VAL_123]], %[[J]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/binop.cpp b/clang/test/CIR/CodeGen/binop.cpp
index b9bdc383b3360..357d9b8198c66 100644
--- a/clang/test/CIR/CodeGen/binop.cpp
+++ b/clang/test/CIR/CodeGen/binop.cpp
@@ -206,9 +206,9 @@ void signed_shift(int a, int b) {
// CIR-LABEL: cir.func{{.*}} @_Z12signed_shiftii(
// CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !s32i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s32i, !cir.ptr<!s32i>
@@ -272,9 +272,9 @@ void unsigned_shift(unsigned a, unsigned b) {
// CIR-LABEL: cir.func{{.*}} @_Z14unsigned_shiftjj(
// CIR-SAME: %[[ARG0:.*]]: !u32i{{.*}}, %[[ARG1:.*]]: !u32i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!u32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !u32i, !cir.ptr<!u32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !u32i, !cir.ptr<!u32i>
@@ -338,9 +338,9 @@ void zext_shift_example(int a, unsigned char b) {
// CIR-LABEL: cir.func{{.*}} @_Z18zext_shift_exampleih(
// CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !u8i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !u8i -> !cir.ptr<!u8i>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u8i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !u8i, !cir.ptr<!u8i>
@@ -410,9 +410,9 @@ void sext_shift_example(int a, signed char b) {
// CIR-LABEL: cir.func{{.*}} @_Z18sext_shift_exampleia(
// CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !s8i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s8i -> !cir.ptr<!s8i>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s8i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s8i, !cir.ptr<!s8i>
@@ -482,9 +482,9 @@ void long_shift_example(long long a, short b) {
// CIR-LABEL: cir.func{{.*}} @_Z18long_shift_examplexs(
// CIR-SAME: %[[ARG0:.*]]: !s64i{{.*}}, %[[ARG1:.*]]: !s16i{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s64i -> !cir.ptr<!s64i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s16i -> !cir.ptr<!s16i>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !s64i -> !cir.ptr<!s64i>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s64i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s16i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s64i>
// CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s64i, !cir.ptr<!s64i>
// CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s16i, !cir.ptr<!s16i>
@@ -558,9 +558,9 @@ void b1(bool a, bool b) {
// CIR-LABEL: cir.func{{.*}} @_Z2b1bb(
// CIR-SAME: %[[ARG0:.*]]: !cir.bool {{.*}}, %[[ARG1:.*]]: !cir.bool {{.*}})
-// CIR: [[A:%[0-9]+]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: [[B:%[0-9]+]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: [[X:%[0-9]+]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: [[A:%[0-9]+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: [[B:%[0-9]+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: [[X:%[0-9]+]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG0]], [[A]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG1]], [[B]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: [[AVAL:%[0-9]+]] = cir.load align(1) [[A]] : !cir.ptr<!cir.bool>, !cir.bool
@@ -662,11 +662,11 @@ void b3(int a, int b, int c, int d) {
// CIR-LABEL: cir.func{{.*}} @_Z2b3iiii(
// CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}, %[[ARG1:.*]]: !s32i {{.*}}, %[[ARG2:.*]]: !s32i {{.*}}, %[[ARG3:.*]]: !s32i {{.*}})
-// CIR: [[A:%[0-9]+]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[B:%[0-9]+]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[C:%[0-9]+]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[D:%[0-9]+]] = cir.alloca "d" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[X:%[0-9]+]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: [[A:%[0-9]+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[B:%[0-9]+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[C:%[0-9]+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[D:%[0-9]+]] = cir.alloca "d" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[X:%[0-9]+]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG0]], [[A]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %[[ARG1]], [[B]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %[[ARG2]], [[C]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/bitfield-union.c b/clang/test/CIR/CodeGen/bitfield-union.c
index d16afbb2acd21..50175a40968fa 100644
--- a/clang/test/CIR/CodeGen/bitfield-union.c
+++ b/clang/test/CIR/CodeGen/bitfield-union.c
@@ -40,7 +40,7 @@ void f() {
// CIR: #bfi_z = #cir.bitfield_info<name = "z", storage_type = !u8i, size = 8, offset = 0, is_signed = true>
// CIR: cir.func {{.*}} @f
-// CIR: [[ALLOC:%.*]] = cir.alloca "d" align(4) !rec_demo -> !cir.ptr<!rec_demo>
+// CIR: [[ALLOC:%.*]] = cir.alloca "d" align(4) : !cir.ptr<!rec_demo>
// CIR: [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
// CIR: [[X:%.*]] = cir.get_member [[ALLOC]][0] {name = "x"} : !cir.ptr<!rec_demo> -> !cir.ptr<!s32i>
// CIR: cir.store align(4) [[ONE]], [[X]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c
index fef2c4d897fd0..1abc23fd36f2a 100644
--- a/clang/test/CIR/CodeGen/bitfields.c
+++ b/clang/test/CIR/CodeGen/bitfields.c
@@ -95,7 +95,7 @@ int load_field(S* s) {
}
// CIR: cir.func {{.*@load_field}}
-// CIR: [[TMP0:%.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: [[TMP0:%.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
@@ -123,7 +123,7 @@ unsigned int load_field_unsigned(A* s) {
}
//CIR: cir.func {{.*}} @load_field_unsigned
-//CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+//CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init : !cir.ptr<!cir.ptr<!rec_A>>
//CIR: [[TMP1:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
//CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][3] {name = "more_bits"} : !cir.ptr<!rec_A> -> !cir.ptr<!u16i>
//CIR: [[TMP3:%.*]] = cir.get_bitfield align(1) (#bfi_more_bits, [[TMP2]] : !cir.ptr<!u16i>) -> !u32i
@@ -151,7 +151,7 @@ void store_field() {
s.e = 3;
}
// CIR: cir.func {{.*@store_field}}
-// CIR: [[TMP0:%.*]] = cir.alloca {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: [[TMP0:%.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_S>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP0]][1] {name = "e"} : !cir.ptr<!rec_S> -> !cir.ptr<!u16i>
// CIR: cir.set_bitfield align(4) (#bfi_e, [[TMP2]] : !cir.ptr<!u16i>, [[TMP1]] : !s32i)
@@ -178,7 +178,7 @@ void store_bitfield_to_bitfield() {
}
// CIR: cir.func {{.*@store_bitfield_to_bitfield}}
-// CIR: [[TMP0:%.*]] = cir.alloca "s" align(4) !rec_S -> !cir.ptr<!rec_S>
+// CIR: [[TMP0:%.*]] = cir.alloca "s" align(4) : !cir.ptr<!rec_S>
// CIR: [[TMP1:%.*]] = cir.get_member [[TMP0]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP2:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP1]] : !cir.ptr<!u64i>) -> !s32i
// CIR: [[TMP3:%.*]] = cir.get_member [[TMP0]][0] {name = "a"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
@@ -229,7 +229,7 @@ void get_volatile(V* v) {
}
// CIR: cir.func {{.*}} @get_volatile
-// CIR: [[TMP0:%.*]] = cir.alloca "v" align(8) init !cir.ptr<!rec_V> -> !cir.ptr<!cir.ptr<!rec_V>>
+// CIR: [[TMP0:%.*]] = cir.alloca "v" align(8) init : !cir.ptr<!cir.ptr<!rec_V>>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_V>>, !cir.ptr<!rec_V>
// CIR: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "b"} : !cir.ptr<!rec_V> -> !cir.ptr<!u64i>
@@ -256,7 +256,7 @@ void set_volatile(V* v) {
v->b = 3;
}
//CIR: cir.func {{.*}} @set_volatile
-//CIR: [[TMP0:%.*]] = cir.alloca "v" align(8) init !cir.ptr<!rec_V> -> !cir.ptr<!cir.ptr<!rec_V>>
+//CIR: [[TMP0:%.*]] = cir.alloca "v" align(8) init : !cir.ptr<!cir.ptr<!rec_V>>
//CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
//CIR: [[TMP2:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_V>>, !cir.ptr<!rec_V>
//CIR: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "b"} : !cir.ptr<!rec_V> -> !cir.ptr<!u64i>
@@ -284,7 +284,7 @@ void unOp(S* s) {
}
// CIR: cir.func {{.*@unOp}}
-// CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "d"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_d, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
diff --git a/clang/test/CIR/CodeGen/bitfields.cpp b/clang/test/CIR/CodeGen/bitfields.cpp
index bd6c6b8169c16..689201c0742b0 100644
--- a/clang/test/CIR/CodeGen/bitfields.cpp
+++ b/clang/test/CIR/CodeGen/bitfields.cpp
@@ -36,7 +36,7 @@ int load_field(S* s) {
return s->c;
}
// CIR: cir.func {{.*}} @_Z10load_field
-// CIR: [[TMP0:%.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: [[TMP0:%.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.load{{.*}} [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
@@ -64,7 +64,7 @@ void store_field() {
s.a = 3;
}
// CIR: cir.func {{.*}} @_Z11store_field
-// CIR: [[TMP0:%.*]] = cir.alloca {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: [[TMP0:%.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_S>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.get_member [[TMP0]][0] {name = "a"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
// CIR: cir.set_bitfield align(4) (#bfi_a, [[TMP2]] : !cir.ptr<!u64i>, [[TMP1]] : !s32i)
@@ -89,7 +89,7 @@ void store_bitfield_to_bitfield(S* s) {
}
// CIR: cir.func {{.*}} @_Z26store_bitfield_to_bitfieldP1S
-// CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i
// CIR: [[TMP2:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "b"} : !cir.ptr<!rec_S> -> !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/bitfields_be.c b/clang/test/CIR/CodeGen/bitfields_be.c
index c7da29717a3e7..5c707ef65e03d 100644
--- a/clang/test/CIR/CodeGen/bitfields_be.c
+++ b/clang/test/CIR/CodeGen/bitfields_be.c
@@ -22,7 +22,7 @@ int init(S* s) {
}
//CIR: cir.func {{.*}} @init
-//CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+//CIR: [[TMP0:%.*]] = cir.alloca "s" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
//CIR: [[TMP1:%.*]] = cir.load align(8) [[TMP0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
//CIR: [[TMP2:%.*]] = cir.get_member [[TMP1]][0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u32i>
//CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u32i>) -> !s32i
@@ -52,7 +52,7 @@ void load(S* s) {
// field 'a'
// CIR: cir.func {{.*}} @load
-// CIR: %[[PTR0:.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[PTR0:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[CONST1:.*]] = cir.const #cir.int<-4> : !s32i
// CIR: %[[VAL0:.*]] = cir.load align(8) %[[PTR0]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: %[[GET0:.*]] = cir.get_member %[[VAL0]][0] {name = "a"} : !cir.ptr<!rec_S> -> !cir.ptr<!u32i>
diff --git a/clang/test/CIR/CodeGen/builtins-x86.c b/clang/test/CIR/CodeGen/builtins-x86.c
index 110b68d119fda..f6991b4493f7f 100644
--- a/clang/test/CIR/CodeGen/builtins-x86.c
+++ b/clang/test/CIR/CodeGen/builtins-x86.c
@@ -213,8 +213,8 @@ v4i test_convertvector(v4f a) {
void foo();
void test_conditional_bzero(void) {
// CIR-LABEL: test_conditional_bzero
-// CIR: %[[ARR:.*]] = cir.alloca {{.*}} !cir.array<!s8i x 20>
-// CIR: %[[SIZE:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.array<!s8i x 20>>
+// CIR: %[[SIZE:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!s8i x 20>> -> !cir.ptr<!s8i>
// CIR: %[[ARR_TO_VOID_PTR:.*]] = cir.cast bitcast %[[ARR_DECAY]] : !cir.ptr<!s8i> -> !cir.ptr<!void>
// CIR: %[[SIZE_LOAD:.*]] = cir.load {{.*}}%[[SIZE]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
index 13df5e29a1749..9147315057ce5 100644
--- a/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
+++ b/clang/test/CIR/CodeGen/call-via-class-member-funcptr.cpp
@@ -50,8 +50,8 @@ class C {
void fn2() { C c1; c1.call_indirect(2); }
// CIR: cir.func {{.*}} @_ZN1C13call_indirectEi(%[[THIS_ARG:.*]]: !cir.ptr<!rec_C> {{.*}}, %[[V_ARG:.*]]: !s32i {{.*}}) -> (!s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
-// CIR: %[[V_ADDR:.*]] = cir.alloca "v" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[V_ADDR:.*]] = cir.alloca "v" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store %[[V_ARG]], %[[V_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
diff --git a/clang/test/CIR/CodeGen/call.c b/clang/test/CIR/CodeGen/call.c
index 4a3f2f98219d6..7d5776922fb44 100644
--- a/clang/test/CIR/CodeGen/call.c
+++ b/clang/test/CIR/CodeGen/call.c
@@ -90,7 +90,7 @@ void f9(void) {
}
// CIR-LABEL: cir.func{{.*}} @f9(){{.*}} {
-// CIR: %[[SLOT:.+]] = cir.alloca "agg.tmp0" align(4) !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[SLOT:.+]] = cir.alloca "agg.tmp0" align(4) : !cir.ptr<!rec_S>
// CIR-NEXT: %[[RET:.+]] = cir.call @f3() : () -> !rec_S
// CIR-NEXT: cir.store align(4) %[[RET]], %[[SLOT]] : !rec_S, !cir.ptr<!rec_S>
// CIR-NEXT: %[[ARG:.+]] = cir.load align(4) %[[SLOT]] : !cir.ptr<!rec_S>, !rec_S
@@ -135,7 +135,7 @@ void f13(void) {
fp();
}
// CIR-LABEL: cir.func{{.*}} @f13()
-// CIR: %[[FP_ALLOCA:.*]] = cir.alloca "fp" {{.*}} !cir.ptr<!cir.func<()>> -> !cir.ptr<!cir.ptr<!cir.func<()>>>
+// CIR: %[[FP_ALLOCA:.*]] = cir.alloca "fp" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<()>>>
// CIR: %[[LOAD_FP:.*]] = cir.load align(8) atomic(seq_cst) %[[FP_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.func<()>>>, !cir.ptr<!cir.func<()>>
// CIR: cir.call %[[LOAD_FP]]() : (!cir.ptr<!cir.func<()>>) -> ()
diff --git a/clang/test/CIR/CodeGen/call.cpp b/clang/test/CIR/CodeGen/call.cpp
index 043fa4c94d1ac..1e01f9c090a86 100644
--- a/clang/test/CIR/CodeGen/call.cpp
+++ b/clang/test/CIR/CodeGen/call.cpp
@@ -35,7 +35,7 @@ int f6() {
}
// CIR-LABEL: cir.func{{.*}} @_Z2f6v() -> (!s32i{{.*}})
-// CIR: %[[#b:]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[#b:]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[#a:]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[#c:]] = cir.const #false
// CIR-NEXT: %{{.+}} = cir.call @_Z2f5iPib(%[[#a]], %[[#b:]], %[[#c]]) : (!s32i {{.*}}, !cir.ptr<!s32i> {{.*}}, !cir.bool {{.*}}) -> (!s32i{{.*}})
@@ -94,7 +94,7 @@ void f12() {
}
// CIR-LABEL: cir.func{{.*}} @_Z3f12v()
-// CIR: %[[#slot:]] = cir.alloca "agg.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[#slot:]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_S>
// CIR-NEXT: %[[#ret:]] = cir.call @_Z3f10v() : () -> !rec_S
// CIR-NEXT: cir.store align(4) %[[#ret]], %[[#slot]] : !rec_S, !cir.ptr<!rec_S>
@@ -142,7 +142,7 @@ void use_TakesFunc() {
}
// CIR-LABEL: _Z9TakesFuncIFivEEDcRKT_
-// CIR-NEXT: %[[FUNC_ALLOCA:.*]] = cir.alloca "f" {{.*}} init const !cir.ptr<!cir.func<() -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<() -> !s32i>>>
+// CIR-NEXT: %[[FUNC_ALLOCA:.*]] = cir.alloca "f" {{.*}} init const : !cir.ptr<!cir.ptr<!cir.func<() -> !s32i>>>
// CIR: %[[FUNC_LOAD:.*]] = cir.load %[[FUNC_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.func<() -> !s32i>>>, !cir.ptr<!cir.func<() -> !s32i>>
// CIR-NEXT: %[[CALL:.*]] = cir.call %[[FUNC_LOAD]]() : (!cir.ptr<!cir.func<() -> !s32i>>) -> (!s32i {llvm.noundef})
diff --git a/clang/test/CIR/CodeGen/cast-cxx20.cpp b/clang/test/CIR/CodeGen/cast-cxx20.cpp
index 87783f64822b1..894a36aeadc31 100644
--- a/clang/test/CIR/CodeGen/cast-cxx20.cpp
+++ b/clang/test/CIR/CodeGen/cast-cxx20.cpp
@@ -14,8 +14,8 @@ void cast1() {
ArrNTy &toArr = arr;
// CIR-LABEL: cir.func {{.*}}@_Z5cast1v()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
- // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 4>>
+ // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const : !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TO_INCOMPLETE:.*]] = cir.cast bitcast %[[ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 4>> -> !cir.ptr<!cir.array<!s32i x 0>>
// CIR: cir.store {{.*}}%[[TO_INCOMPLETE]], %[[TO_ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
@@ -29,8 +29,8 @@ void cast2() {
Arr4Ty arr = {};
CArrNTy &toArr = arr;
// CIR-LABEL: cir.func {{.*}}@_Z5cast2v()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
- // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!s32i x 4>>
+ // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const : !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TO_INCOMPLETE:.*]] = cir.cast bitcast %[[ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 4>> -> !cir.ptr<!cir.array<!s32i x 0>>
// CIR: cir.store {{.*}}%[[TO_INCOMPLETE]], %[[TO_ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
//
@@ -43,8 +43,8 @@ void cast2() {
void cast3() {
int (&&toArr)[] = static_cast<int[]>(3);
// CIR-LABEL: cir.func {{.*}}@_Z5cast3v()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.array<!s32i x 1> -> !cir.ptr<!cir.array<!s32i x 1>>
- // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!cir.array<!s32i x 1>>
+ // CIR: %[[TO_ARR_ALLOCA:.*]] = cir.alloca "toArr" {{.*}} init const : !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TO_INCOMPLETE:.*]] = cir.cast bitcast %[[TMP_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!cir.array<!s32i x 0>>
// CIR: cir.store {{.*}}%[[TO_INCOMPLETE]], %[[TO_ARR_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 0>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
//
@@ -59,8 +59,8 @@ void cast4() {
CArrNTy* const volatile *const constArrPP = arrPP;
// CIR-LABEL: cir.func {{.*}}@_Z5cast4v()
- // CIR: %[[ARR_PP_ALLOCA:.*]] = cir.alloca "arrPP" {{.*}} !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
- // CIR: %[[CONST_ARR_ALLOCA:.*]] = cir.alloca "constArrPP" {{.*}} init const !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>>
+ // CIR: %[[ARR_PP_ALLOCA:.*]] = cir.alloca "arrPP" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
+ // CIR: %[[CONST_ARR_ALLOCA:.*]] = cir.alloca "constArrPP" {{.*}} init const : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>>
// CIR: %[[LOAD_ARR_PP:.*]] = cir.load align(8) %[[ARR_PP_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>
// CIR: %[[CONST_ARR_CAST:.*]] = cir.cast bitcast %[[CONST_ARR_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
// CIR: cir.store{{.*}} %[[LOAD_ARR_PP]], %[[CONST_ARR_CAST]] : !cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>, !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 4>>>>
diff --git a/clang/test/CIR/CodeGen/cast.c b/clang/test/CIR/CodeGen/cast.c
index 35c3071c41c7c..0ac9934e61364 100644
--- a/clang/test/CIR/CodeGen/cast.c
+++ b/clang/test/CIR/CodeGen/cast.c
@@ -28,7 +28,7 @@ union Union toUnionAssign() {
// CIR-LABEL: toUnionAssign()
// LLVM-LABEL: toUnionAssign()
//
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_Union -> !cir.ptr<!rec_Union>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Union>
// LLVM: %[[RET_ALLOCA:.*]] = alloca %union.Union
union Union u;
u = (union Union)42;
diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp
index a81a90ffa89be..f3a1bfaa8ed72 100644
--- a/clang/test/CIR/CodeGen/cast.cpp
+++ b/clang/test/CIR/CodeGen/cast.cpp
@@ -8,8 +8,8 @@ unsigned char cxxstaticcast_0(unsigned int x) {
}
// CIR: cir.func{{.*}} @_Z15cxxstaticcast_0j
-// CIR: %[[XPTR:[0-9]+]] = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[RV:[0-9]+]] = cir.alloca "__retval" align(1) !u8i -> !cir.ptr<!u8i>
+// CIR: %[[XPTR:[0-9]+]] = cir.alloca "x" align(4) init : !cir.ptr<!u32i>
+// CIR: %[[RV:[0-9]+]] = cir.alloca "__retval" align(1) : !cir.ptr<!u8i>
// CIR: cir.store %arg0, %[[XPTR]] : !u32i, !cir.ptr<!u32i>
// CIR: %[[XVAL:[0-9]+]] = cir.load{{.*}} %[[XPTR]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[CASTED:[0-9]+]] = cir.cast integral %[[XVAL]] : !u32i -> !u8i
@@ -90,7 +90,7 @@ bool cptr(void *d) {
}
// CIR: cir.func{{.*}} @_Z4cptrPv(%arg0: !cir.ptr<!void>
-// CIR: %[[DPTR:[0-9]+]] = cir.alloca "d" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[DPTR:[0-9]+]] = cir.alloca "d" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[DVAL:[0-9]+]] = cir.load{{.*}} %[[DPTR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %{{[0-9]+}} = cir.cast ptr_to_bool %[[DVAL]] : !cir.ptr<!void> -> !cir.bool
diff --git a/clang/test/CIR/CodeGen/choose-expr.cpp b/clang/test/CIR/CodeGen/choose-expr.cpp
index 66d8597de3c6e..773230ee4d48a 100644
--- a/clang/test/CIR/CodeGen/choose-expr.cpp
+++ b/clang/test/CIR/CodeGen/choose-expr.cpp
@@ -9,7 +9,7 @@ void choose_expr() {
int a = __builtin_choose_expr(1, 2, 3);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i
// CIR: cir.store {{.*}} %[[CONST_2]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
@@ -25,9 +25,9 @@ void choose_expr_non_constant() {
int c = __builtin_choose_expr(1, a, b);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store {{.*}} %[[TMP_A]], %[[C_ADDR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/class.cpp b/clang/test/CIR/CodeGen/class.cpp
index 1d63accdfe489..6baf9e4a02e36 100644
--- a/clang/test/CIR/CodeGen/class.cpp
+++ b/clang/test/CIR/CodeGen/class.cpp
@@ -52,7 +52,7 @@ class Derived : public Base {
int use(Derived *d) { return d->b; }
// CIR: cir.func{{.*}} @_Z3useP7Derived(%[[ARG0:.*]]: !cir.ptr<!rec_Derived>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[ARG0]], %[[D_ADDR]]
// CIR: %[[D_PTR:.*]] = cir.load align(8) %0
// CIR: %[[D_B_ADDR:.*]] = cir.get_member %[[D_PTR]][1] {name = "b"}
@@ -70,7 +70,7 @@ int use_base() {
}
// CIR: cir.func{{.*}} @_Z8use_basev
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} !rec_Derived -> !cir.ptr<!rec_Derived>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} : !cir.ptr<!rec_Derived>
// CIR: %[[BASE_ADDR:.*]] cir.base_class_addr %[[D_ADDR]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[D_A_ADDR:.*]] = cir.get_member %2[0] {name = "a"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: %[[D_A:.*]] = cir.load align(4) %3 : !cir.ptr<!s32i>, !s32i
@@ -88,7 +88,7 @@ int use_base_via_pointer(Derived *d) {
}
// CIR: cir.func{{.*}} @_Z20use_base_via_pointerP7Derived(%[[ARG0:.*]]: !cir.ptr<!rec_Derived>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[ARG0]], %[[D_ADDR]]
// CIR: %[[D:.*]] = cir.load align(8) %[[D_ADDR]]
// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[D]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
@@ -109,7 +109,7 @@ void use_empty_derived2() {
}
// CIR: cir.func{{.*}} @_Z18use_empty_derived2v()
-// CIR: %0 = cir.alloca "d2" {{.*}} !rec_EmptyDerived2 -> !cir.ptr<!rec_EmptyDerived2>
+// CIR: %0 = cir.alloca "d2" {{.*}} : !cir.ptr<!rec_EmptyDerived2>
// CIR: cir.return
// LLVM: define{{.*}} void @_Z18use_empty_derived2v
diff --git a/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp b/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp
index f772ea8362ba1..360d4f1253f23 100644
--- a/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-automatic-eh.cpp
@@ -18,8 +18,8 @@ void test_cleanup_with_automatic_storage_duration() {
}
// CIR: cir.func{{.*}} @_Z44test_cleanup_with_automatic_storage_durationv()
-// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
-// CIR: %[[REF:.*]] = cir.alloca "ref" {{.*}} init const !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_Struk>
+// CIR: %[[REF:.*]] = cir.alloca "ref" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Struk>>
// CIR: cir.call @_ZN5StrukC1Ev(%[[REF_TMP]])
// CIR: cir.cleanup.scope {
// CIR: cir.store{{.*}} %[[REF_TMP]], %[[REF]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
index 473a14f8a7aba..897dbcf78ccba 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
@@ -32,8 +32,8 @@ void test_ternary_temporary(bool c, int x) {
int result = c ? S().get() : x;
}
// CIR-LABEL: @_Z22test_ternary_temporarybi
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_S>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE:.*]] = cir.const #false
@@ -135,10 +135,10 @@ void test_ternary_both_branches(bool c) {
int result = c ? A().get() : B().get();
}
// CIR-LABEL: @_Z26test_ternary_both_branchesb
-// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
-// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE_A:.*]] = cir.const #false
@@ -277,10 +277,10 @@ int test_return_ternary(bool c) {
return c ? A().get() : B().get();
}
// CIR-LABEL: @_Z19test_return_ternaryb
-// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
-// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE_A:.*]] = cir.const #false
@@ -430,7 +430,7 @@ int test_false_positive_conditional(bool c) {
}
// CIR-LABEL: @_Z31test_false_positive_conditionalb
// CIR-NOT: cir.alloca "cleanup.cond"
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev(%[[TMP]])
// CIR: cir.cleanup.scope {
// CIR: %[[VAL:.*]] = cir.call @_ZN1S3getEv(%[[TMP]])
@@ -514,11 +514,11 @@ void test_nested_ewc(bool c1, bool c2) {
}
// CIR-LABEL: @_Z15test_nested_ewcbb
-// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
-// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_T -> !cir.ptr<!rec_T>
+// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!rec_T>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_T>
// Inner cir.scope for the statement expression.
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_T>
// Inner ternary: c1 ? T(1) : T(2) — no cleanup scope needed.
// CIR: %[[C1:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: cir.if %[[C1]] {
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
index 942035461ccde..0980c74501821 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
@@ -40,9 +40,9 @@ Wrapper makeWrapper() {
}
// CIR: cir.func {{.*}} @_Z11makeWrapperv() -> !rec_Wrapper
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_Wrapper -> !cir.ptr<!rec_Wrapper>
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3Aunique_ptr3CBase3E -> !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Wrapper>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>
// CIR: cir.cleanup.scope {
// CIR: %[[FLAG:.*]] = cir.load{{.*}} %{{.*}}
// CIR: %[[FALSE:.*]] = cir.const #false
@@ -191,16 +191,16 @@ void APFixedPoint::add(int x) const {
}
// CIR: cir.func {{.*}} @_ZNK12APFixedPoint3addEi(%{{.*}}: !cir.ptr<!rec_APFixedPoint>{{.*}}, %{{.*}}: !s32i{{.*}})
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[THISVAL:.*]] = cir.alloca "ThisVal" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
-// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[THISVAL:.*]] = cir.alloca "ThisVal" {{.*}} : !cir.ptr<!rec_APInt>
+// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X_BOOL:.*]] = cir.cast int_to_bool %[[X]]
// CIR: cir.if %[[X_BOOL]] {
-// CIR: %[[AGG_TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
+// CIR: %[[AGG_TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_APInt>
// CIR: cir.cleanup.scope {
// CIR: %[[X2:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X2_BOOL:.*]] = cir.cast int_to_bool %[[X2]]
@@ -357,17 +357,17 @@ void makeEntry() {
}
// CIR: cir.func {{.*}} @_Z9makeEntryv()
-// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Iter -> !cir.ptr<!rec_Iter>
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_Path -> !cir.ptr<!rec_Path>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_Iter>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_Path>
// CIR: cir.cleanup.scope {
// CIR: cir.cleanup.scope {
// CIR: %[[CALL:.*]] = cir.call @_ZN4ItercvbEv(%[[REF_TMP]])
// CIR: cir.if %[[CALL]] {
-// CIR: %[[ENSURED_T:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
+// CIR: %[[ENSURED_T:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_Entry>
// CIR: cir.call @_ZN5EntryC1Ev(%[[ENSURED_T]])
// CIR: } else {
-// CIR: %[[ENSURED_F:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
+// CIR: %[[ENSURED_F:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_Entry>
// CIR: %{{.*}} = cir.get_global @g_path
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
index 66a40d118b3ca..79c614beb5a11 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
@@ -40,9 +40,9 @@ Wrapper makeWrapper() {
}
// CIR: cir.func {{.*}} @_Z11makeWrapperv() -> !rec_Wrapper
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_Wrapper -> !cir.ptr<!rec_Wrapper>
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3Aunique_ptr3CBase3E -> !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Wrapper>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_std3A3Aunique_ptr3CBase3E>
// CIR: cir.cleanup.scope {
// CIR: %[[FLAG:.*]] = cir.load{{.*}} %{{.*}}
// CIR: %[[FALSE:.*]] = cir.const #false
@@ -144,16 +144,16 @@ void APFixedPoint::add(int x) const {
}
// CIR: cir.func {{.*}} @_ZNK12APFixedPoint3addEi(%{{.*}}: !cir.ptr<!rec_APFixedPoint>{{.*}}, %{{.*}}: !s32i{{.*}})
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[THISVAL:.*]] = cir.alloca "ThisVal" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
-// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[THISVAL:.*]] = cir.alloca "ThisVal" {{.*}} : !cir.ptr<!rec_APInt>
+// CIR: %[[CLEANUP_COND_TRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND_FALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X_BOOL:.*]] = cir.cast int_to_bool %[[X]]
// CIR: cir.if %[[X_BOOL]] {
-// CIR: %[[AGG_TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_APInt -> !cir.ptr<!rec_APInt>
+// CIR: %[[AGG_TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_APInt>
// CIR: cir.cleanup.scope {
// CIR: %[[X2:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[X2_BOOL:.*]] = cir.cast int_to_bool %[[X2]]
@@ -278,17 +278,17 @@ void makeEntry() {
}
// CIR: cir.func {{.*}} @_Z9makeEntryv()
-// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Iter -> !cir.ptr<!rec_Iter>
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_Path -> !cir.ptr<!rec_Path>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_Iter>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[AGG_TMP0:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_Path>
// CIR: cir.cleanup.scope {
// CIR: cir.cleanup.scope {
// CIR: %[[CALL:.*]] = cir.call @_ZN4ItercvbEv(%[[REF_TMP]])
// CIR: cir.if %[[CALL]] {
-// CIR: %[[ENSURED_T:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
+// CIR: %[[ENSURED_T:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_Entry>
// CIR: cir.call @_ZN5EntryC1Ev(%[[ENSURED_T]])
// CIR: } else {
-// CIR: %[[ENSURED_F:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_Entry -> !cir.ptr<!rec_Entry>
+// CIR: %[[ENSURED_F:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_Entry>
// CIR: %{{.*}} = cir.get_global @g_path
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store %[[TRUE]], %[[CLEANUP_COND]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional.cpp b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
index 2d11d9849eeaa..0c26b7ab8aed6 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
@@ -15,8 +15,8 @@ void test_ternary_temporary(bool c, int x) {
int result = c ? S().get() : x;
}
// CIR-LABEL: @_Z22test_ternary_temporarybi
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_S>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// The cleanup scope wraps the full expression so cleanups run on all exits.
// CIR: cir.cleanup.scope {
// Load condition, then active flag false before the ternary (destructor guard).
@@ -117,10 +117,10 @@ void test_ternary_both_branches(bool c) {
int result = c ? A().get() : B().get();
}
// CIR-LABEL: @_Z26test_ternary_both_branchesb
-// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
-// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// Both active flags start false; each branch sets its own to true when it runs.
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
@@ -234,10 +234,10 @@ int test_return_ternary(bool c) {
return c ? A().get() : B().get();
}
// CIR-LABEL: @_Z19test_return_ternaryb
-// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
-// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMPA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_A>
+// CIR: %[[ACTA:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[TMPB:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[ACTB:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[FALSE_A:.*]] = cir.const #false
@@ -366,7 +366,7 @@ int test_false_positive_conditional(bool c) {
}
// No cleanup.cond alloca — the destructor is unconditional.
// CIR-NOT: cir.alloca "cleanup.cond"
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev(%[[TMP]])
// The cleanup scope wraps the get() + select + store.
// CIR: cir.cleanup.scope {
@@ -435,11 +435,11 @@ void test_nested_ewc(bool c1, bool c2) {
}
// CIR-LABEL: @_Z15test_nested_ewcbb
-// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
-// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_T -> !cir.ptr<!rec_T>
+// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!rec_T>
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_T>
// cir.scope for the statement expression.
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_T -> !cir.ptr<!rec_T>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_T>
// Inner ternary: c1 ? T(1) : T(2) — no cleanup scope needed (no deferred dtors).
// CIR: %[[C1:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
// CIR: cir.if %[[C1]] {
@@ -576,11 +576,11 @@ void test_lvalue_ternary_cleanup(bool c, V &y) {
y = c ? V(1) : V(2);
}
// CIR-LABEL: @_Z27test_lvalue_ternary_cleanupbR1V
-// CIR: %[[REFTMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_V -> !cir.ptr<!rec_V>
-// CIR: %[[UTRUE:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_U -> !cir.ptr<!rec_U>
-// CIR: %[[ACTTRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[UFALSE:.*]] = cir.alloca "ref.tmp2" {{.*}} !rec_U -> !cir.ptr<!rec_U>
-// CIR: %[[ACTFALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[REFTMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_V>
+// CIR: %[[UTRUE:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_U>
+// CIR: %[[ACTTRUE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[UFALSE:.*]] = cir.alloca "ref.tmp2" {{.*}} : !cir.ptr<!rec_U>
+// CIR: %[[ACTFALSE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// The outer cleanup scope wraps the full expression containing the ternary
// and the operator= call.
// CIR: cir.cleanup.scope {
@@ -702,13 +702,13 @@ void test_lvalue_reload(bool c) {
sink = &r;
}
// CIR-LABEL: @_Z18test_lvalue_reloadb
-// CIR: %[[R_REF:.*]] = cir.alloca "r" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_R -> !cir.ptr<!rec_R>
-// CIR: %[[ACT0:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_R -> !cir.ptr<!rec_R>
-// CIR: %[[ACT1:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[R_REF:.*]] = cir.alloca "r" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_R>
+// CIR: %[[ACT0:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_R>
+// CIR: %[[ACT1:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// The spill slot for the lvalue's base pointer.
-// CIR: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.cleanup.scope {
// CIR: cir.store {{.*}}, %[[ACT0]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: cir.store {{.*}}, %[[ACT1]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -807,8 +807,8 @@ _Complex float test_complex_cond_cleanup(bool b, _Complex float x) {
return b ? CplxD().get() : x;
}
// CIR-LABEL: @_Z25test_complex_cond_cleanupbCf
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_CplxD -> !cir.ptr<!rec_CplxD>
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_CplxD>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// The full expression is wrapped in a single cleanup scope.
// CIR: cir.cleanup.scope {
// CIR: %[[COND:.*]] = cir.load {{.*}} : !cir.ptr<!cir.bool>, !cir.bool
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp b/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp
index 3812ffa6c9e9b..780b90fb98fe5 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-goto-out.cpp
@@ -23,7 +23,7 @@ end:;
// CIR-LABEL: cir.func {{.*}} @_Z19test_goto_only_exitb
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_Z3useR20StructWithDestructor(%[[A_ADDR]])
// CIR: cir.goto "end"
@@ -82,7 +82,7 @@ end:;
// CIR-LABEL: cir.func {{.*}} @_Z27test_goto_among_other_exitsb
// CIR: cir.scope {
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
@@ -158,10 +158,10 @@ void test_goto_inner_to_outer(bool cond) {
}
// CIR-LABEL: cir.func {{.*}} @_Z24test_goto_inner_to_outerb
-// CIR: %[[OUTER_ADDR:.*]] = cir.alloca "outer" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[OUTER_ADDR:.*]] = cir.alloca "outer" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
-// CIR: %[[INNER_ADDR:.*]] = cir.alloca "inner" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[INNER_ADDR:.*]] = cir.alloca "inner" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
@@ -256,10 +256,10 @@ end:;
// CIR-LABEL: cir.func {{.*}} @_Z27test_goto_out_of_two_nestedb
// CIR: cir.scope {
-// CIR: %[[OUTER_ADDR:.*]] = cir.alloca "outer" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[OUTER_ADDR:.*]] = cir.alloca "outer" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
-// CIR: %[[INNER_ADDR:.*]] = cir.alloca "inner" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[INNER_ADDR:.*]] = cir.alloca "inner" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp b/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp
index e06b1a2396591..fafe7e1d1918a 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-goto-within.cpp
@@ -21,7 +21,7 @@ void test_goto_within_cleanup(bool cond) {
}
// CIR-LABEL: cir.func {{.*}} @_Z24test_goto_within_cleanupb
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
@@ -87,7 +87,7 @@ void test_goto_jump_into_nested_op(bool cond1, bool cond2) {
}
// CIR-LABEL: cir.func {{.*}} @_Z29test_goto_jump_into_nested_opbb
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.scope {
// CIR: cir.if {{.*}} {
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp b/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp
index 44486f1cee871..6fe8de8757400 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-tmp-with-exception.cpp
@@ -8,7 +8,7 @@ struct StructWithDestructor {
void cleanup_scope_with_without_body() { StructWithDestructor a; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.yield
// CIR: } cleanup all {
@@ -21,7 +21,7 @@ void cleanup_scope_with_body_and_cleanup() {
a.procedure();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN20StructWithDestructor9procedureEv(%[[A_ADDR]]) : (!cir.ptr<!rec_StructWithDestructor> {{.*}}) -> ()
// CIR: cir.yield
diff --git a/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp b/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp
index 580e5e35929bd..5f5c3f67c136c 100644
--- a/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-scope-tmp.cpp
@@ -8,7 +8,7 @@ struct StructWithDestructor {
void cleanup_scope_with_without_body() { StructWithDestructor a; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.yield
// CIR: } cleanup normal {
@@ -21,7 +21,7 @@ void cleanup_scope_with_body_and_cleanup() {
a.procedure();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithDestructor -> !cir.ptr<!rec_StructWithDestructor>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithDestructor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN20StructWithDestructor9procedureEv(%[[A_ADDR]]) : (!cir.ptr<!rec_StructWithDestructor> {{.*}}) -> ()
// CIR: cir.yield
diff --git a/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp b/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp
index b7da3d2e046b0..e64888453d31f 100644
--- a/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-throw-from-cleanup.cpp
@@ -17,8 +17,8 @@ void testSwitchWithCleanup(int n) {
// region runs the destructor for `x` on the EH unwind path.
// CIR: cir.func{{.*}} @_Z21testSwitchWithCleanupi(%[[ARG:.*]]: !s32i
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} !rec_Local -> !cir.ptr<!rec_Local>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} : !cir.ptr<!rec_Local>
// CIR: cir.store %[[ARG]], %[[N_ADDR]] : !s32i
// CIR: cir.cleanup.scope {
// CIR: %[[EXN:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i>
@@ -39,8 +39,8 @@ void testSwitchWithCleanup(int n) {
// cleanup chain that runs the destructor and then resumes.
// CIR-FLAT: cir.func{{.*}} @_Z21testSwitchWithCleanupi(%[[ARG:.*]]: !s32i
-// CIR-FLAT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-FLAT: %[[X:.*]] = cir.alloca "x" {{.*}} !rec_Local -> !cir.ptr<!rec_Local>
+// CIR-FLAT: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR-FLAT: %[[X:.*]] = cir.alloca "x" {{.*}} : !cir.ptr<!rec_Local>
// CIR-FLAT: cir.store %[[ARG]], %[[N_ADDR]]
// CIR-FLAT: cir.br ^[[BODY:.+]]
// CIR-FLAT: ^[[BODY]]:
diff --git a/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp b/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp
index dd97db4273c4c..138c6c1e17011 100644
--- a/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-throwing-dtor.cpp
@@ -25,7 +25,7 @@ void test_throwing_dtor_cleanup() {
// High-level: the cleanup region's dtor call does NOT have nothrow.
//
// CIR: cir.func{{.*}} @_Z26test_throwing_dtor_cleanupv()
-// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} !rec_ThrowingDtor -> !cir.ptr<!rec_ThrowingDtor>
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!rec_ThrowingDtor>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN12ThrowingDtor11doSomethingEv(%[[C]])
// CIR: cir.yield
@@ -38,7 +38,7 @@ void test_throwing_dtor_cleanup() {
// becomes a try_call that unwinds to a terminate block.
//
// CIR-FLAT: cir.func{{.*}} @_Z26test_throwing_dtor_cleanupv()
-// CIR-FLAT: %[[C:.*]] = cir.alloca "c" {{.*}} !rec_ThrowingDtor -> !cir.ptr<!rec_ThrowingDtor>
+// CIR-FLAT: %[[C:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!rec_ThrowingDtor>
// CIR-FLAT: cir.br ^[[BODY:bb[0-9]+]]
//
// Body: doSomething becomes a try_call.
diff --git a/clang/test/CIR/CodeGen/cleanup.cpp b/clang/test/CIR/CodeGen/cleanup.cpp
index f043b875abe2c..ea3d9c55d05dd 100644
--- a/clang/test/CIR/CodeGen/cleanup.cpp
+++ b/clang/test/CIR/CodeGen/cleanup.cpp
@@ -14,7 +14,7 @@ void test_cleanup() {
}
// CHECK: cir.func{{.*}} @_Z12test_cleanupv()
-// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S_ADDR]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: cir.return
@@ -30,10 +30,10 @@ void test_cleanup_ifelse(bool b) {
// CHECK: cir.scope {
// CHECK: %[[B:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.bool>
// CHECK: cir.if %[[B]] {
-// CHECK: %[[S:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: } else {
-// CHECK: %[[S_TOO:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S_TOO:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S_TOO]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: }
// CHECK: }
@@ -50,7 +50,7 @@ void test_cleanup_for() {
// CHECK: cir.for : cond {
// CHECK: } body {
// CHECK: cir.scope {
-// CHECK: %[[S:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: }
// CHECK: cir.yield
@@ -70,11 +70,11 @@ void test_cleanup_nested() {
}
// CHECK: cir.func{{.*}} @_Z19test_cleanup_nestedv()
-// CHECK: %[[OUTER:.*]] = cir.alloca "outer" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[OUTER:.*]] = cir.alloca "outer" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.scope {
-// CHECK: %[[MIDDLE:.*]] = cir.alloca "middle" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[MIDDLE:.*]] = cir.alloca "middle" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.scope {
-// CHECK: %[[INNER:.*]] = cir.alloca "inner" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[INNER:.*]] = cir.alloca "inner" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD1Ev(%[[INNER]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: }
// CHECK: cir.call @_ZN5StrukD1Ev(%[[MIDDLE]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
@@ -89,7 +89,7 @@ void test_expr_with_cleanup() {
}
// CHECK: cir.func{{.*}} @_Z22test_expr_with_cleanupv()
-// CHECK: %[[S:.*]] = cir.alloca {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_Z7use_refRK5Struk(%[[S]])
// CHECK: cir.call @_ZN5StrukD1Ev(%[[S]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK: cir.return
@@ -104,9 +104,9 @@ void complex_expr_with_cleanup() {
}
// CHECK: cir.func{{.*}} @_Z25complex_expr_with_cleanupv()
-// CHECK: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_ComplexContainer -> !cir.ptr<!rec_ComplexContainer>
-// CHECK: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_ComplexContainer>
+// CHECK: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[CONST_10:.*]] = cir.const #cir.int<10> : !s32i
// CHECK: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CHECK: %[[ARG_COMPLEX:.*]] = cir.complex.create %[[CONST_10]], %[[CONST_0]] : !s32i -> !cir.complex<!s32i>
@@ -128,10 +128,10 @@ void complex_expr_with_cleanup_inside_cleanupscope() {
}
// CHECK: cir.func{{.*}} @_Z45complex_expr_with_cleanup_inside_cleanupscopev()
-// CHECK: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_ComplexContainerWithDtor -> !cir.ptr<!rec_ComplexContainerWithDtor>
-// CHECK: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CHECK: %[[TEMP_ADDR:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[CONTAINER_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_ComplexContainerWithDtor>
+// CHECK: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[TEMP_ADDR:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[CONST_10:.*]] = cir.const #cir.int<10> : !s32i
// CHECK: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CHECK: %[[ARG_COMPLEX:.*]] = cir.complex.create %[[CONST_10]], %[[CONST_0]] : !s32i -> !cir.complex<!s32i>
@@ -155,8 +155,8 @@ void test_cleanup_with_automatic_storage_duration() {
}
// CHECK: cir.func{{.*}} @_Z44test_cleanup_with_automatic_storage_durationv()
-// CHECK: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
-// CHECK: %[[REF:.*]] = cir.alloca "ref" {{.*}} init const !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
+// CHECK: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_Struk>
+// CHECK: %[[REF:.*]] = cir.alloca "ref" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: cir.cleanup.scope {
// CHECK: cir.store{{.*}} %[[REF_TMP]], %[[REF]]
// CHECK: cir.yield
diff --git a/clang/test/CIR/CodeGen/cmp.cpp b/clang/test/CIR/CodeGen/cmp.cpp
index 28c0e78974c9f..921d431b32d59 100644
--- a/clang/test/CIR/CodeGen/cmp.cpp
+++ b/clang/test/CIR/CodeGen/cmp.cpp
@@ -16,9 +16,9 @@ void c0(int a, int b) {
// CIR-LABEL: cir.func{{.*}} @_Z2c0ii(
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]]
// CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]]
@@ -142,9 +142,9 @@ void c0_unsigned(unsigned int a, unsigned int b) {
// CIR-LABEL: cir.func{{.*}} @_Z11c0_unsignedjj(
-// CIR: %[[U_A_PTR:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[U_B_PTR:.*]] = cir.alloca "b" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[U_X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[U_A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[U_B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[U_X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[UA1:.*]] = cir.load{{.*}} %[[U_A_PTR]]
// CIR: %[[UB1:.*]] = cir.load{{.*}} %[[U_B_PTR]]
@@ -266,9 +266,9 @@ void c0_float(float a, float b) {
}
// CIR-LABEL: cir.func{{.*}} @_Z8c0_floatff(%arg0: !cir.float{{.*}}, %arg1: !cir.float{{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: cir.store{{.*}} %arg0, %[[A_PTR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: cir.store{{.*}} %arg1, %[[B_PTR]] : !cir.float, !cir.ptr<!cir.float>
@@ -347,8 +347,8 @@ void pointer_cmp(int *a, int *b) {
}
// CIR-LABEL: cir.func{{.*}} @_Z11pointer_cmpPiS_(%arg0: !cir.ptr<!s32i>{{.*}}, %arg1: !cir.ptr<!s32i>{{.*}}){{.*}} {
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -402,9 +402,9 @@ void bool_cmp(bool a, bool b) {
}
// CIR-LABEL: cir.func{{.*}} @_Z8bool_cmpbb(%arg0: !cir.bool{{.*}}, %arg1: !cir.bool{{.*}}){{.*}} {
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[X_PTR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[A1_INT:.*]] = cir.cast bool_to_int %[[A1]] : !cir.bool -> !s32i
diff --git a/clang/test/CIR/CodeGen/comma.c b/clang/test/CIR/CodeGen/comma.c
index ea513a241543f..187b9624d5da7 100644
--- a/clang/test/CIR/CodeGen/comma.c
+++ b/clang/test/CIR/CodeGen/comma.c
@@ -17,10 +17,10 @@ void comma(void) {
}
// CIR-LABEL: cir.func{{.*}} @comma()
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} !s8i -> !cir.ptr<!s8i>
-// CIR: %[[F:.*]] = cir.alloca "f" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!s8i>
+// CIR: %[[F:.*]] = cir.alloca "f" {{.*}} : !cir.ptr<!cir.float>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.store{{.*}} %[[TRUE]], %[[B]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
diff --git a/clang/test/CIR/CodeGen/complex-atomic-cast.c b/clang/test/CIR/CodeGen/complex-atomic-cast.c
index 5a1f71f8ab8d8..112e369d7e2ff 100644
--- a/clang/test/CIR/CodeGen/complex-atomic-cast.c
+++ b/clang/test/CIR/CodeGen/complex-atomic-cast.c
@@ -10,8 +10,8 @@ void complex_to_atomic_complex() {
_Atomic _Complex int b = a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store {{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
diff --git a/clang/test/CIR/CodeGen/complex-builtins.cpp b/clang/test/CIR/CodeGen/complex-builtins.cpp
index 0627597223069..d05631d06db88 100644
--- a/clang/test/CIR/CodeGen/complex-builtins.cpp
+++ b/clang/test/CIR/CodeGen/complex-builtins.cpp
@@ -11,8 +11,8 @@ void foo() {
int _Complex r = __builtin_choose_expr(true, a, b);
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[COMPLEX_R:.*]] = cir.alloca "r" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_R:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[COMPLEX_R]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -39,8 +39,8 @@ void foo2() {
double real = __builtin_creal(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[INIT:.*]] = cir.alloca "real" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "real" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[REAL]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -64,8 +64,8 @@ void foo3() {
double imag = __builtin_cimag(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[INIT:.*]] = cir.alloca "imag" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "imag" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[IMAG]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -89,8 +89,8 @@ void foo4() {
float _Complex b = __builtin_conjf(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[RESULT:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex-cast.cpp b/clang/test/CIR/CodeGen/complex-cast.cpp
index ea35111c860ef..7746014b2d648 100644
--- a/clang/test/CIR/CodeGen/complex-cast.cpp
+++ b/clang/test/CIR/CodeGen/complex-cast.cpp
@@ -385,8 +385,8 @@ void complex_user_defined_cast() {
int _Complex c = p;
}
-// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!rec_Point>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[P_VALUE:.*]] = cir.get_global @__const._Z25complex_user_defined_castv.p : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[P_VALUE]] to %[[P_ADDR]] : !cir.ptr<!rec_Point>
// CIR: %[[POINT_TO_COMPLEX:.*]] = cir.call @_ZZ25complex_user_defined_castvENK5PointcvCiEv(%[[P_ADDR]]) : (!cir.ptr<!rec_Point> {llvm.align = 4 : i64, llvm.dereferenceable = 8 : i64, llvm.nonnull, llvm.noundef}) -> (!cir.complex<!s32i> {llvm.noundef})
diff --git a/clang/test/CIR/CodeGen/complex-compound-assignment.cpp b/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
index adb34fff72fb6..04a7998eb678e 100644
--- a/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
+++ b/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
@@ -17,8 +17,8 @@ void foo() {
b += a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT:.*]] = cir.complex.add %[[TMP_B]], %[[TMP_A]] : !cir.complex<!cir.float>
@@ -61,8 +61,8 @@ void foo1() {
b -= a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT:.*]] = cir.complex.sub %[[TMP_B]], %[[TMP_A]] : !cir.complex<!cir.float>
@@ -105,8 +105,8 @@ void foo2() {
b += a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[RESULT:.*]] = cir.complex.add %[[TMP_B]], %[[TMP_A]] : !cir.complex<!s32i>
@@ -149,8 +149,8 @@ void foo3() {
b += a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
// 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
@@ -234,9 +234,9 @@ void foo4() {
}
#endif
-// CXX_CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CXX_CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CXX_CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CXX_CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CXX_CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CXX_CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CXX_CIR: %[[TMP_A:.*]] = cir.load volatile {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CXX_CIR: %[[TMP_B:.*]] = cir.load volatile {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CXX_CIR: %[[RESULT:.*]] = cir.complex.add %[[TMP_B]], %[[TMP_A]] : !cir.complex<!s32i>
@@ -293,8 +293,8 @@ void foo5() {
a += b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// 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
@@ -333,8 +333,8 @@ void foo6() {
b *= a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!s32i> -> !s32i
@@ -395,8 +395,8 @@ void foo7() {
b *= a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!cir.float> -> !cir.float
@@ -497,8 +497,8 @@ void foo8() {
a *= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// 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
@@ -540,8 +540,8 @@ void foo10() {
a /= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// 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
@@ -590,8 +590,8 @@ void foo11() {
a /= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// 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
@@ -633,8 +633,8 @@ void foo12() {
a /= b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[B_COMPLEX:.*]] = cir.complex.create %[[TMP_B]], %[[CONST_0]] : !s32i -> !cir.complex<!s32i>
@@ -707,8 +707,8 @@ void foo13() {
b /= (a / b);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
// 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
@@ -828,8 +828,8 @@ void foo9() {
}
#endif
-// C_CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// C_CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// C_CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// C_CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.float>
// C_CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// C_CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// C_CIR: %[[A_REAL:.*]] = cir.complex.real %[[A_ADDR]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex-mul-div.cpp b/clang/test/CIR/CodeGen/complex-mul-div.cpp
index a8125e2c48621..dbdc9b2040cc1 100644
--- a/clang/test/CIR/CodeGen/complex-mul-div.cpp
+++ b/clang/test/CIR/CodeGen/complex-mul-div.cpp
@@ -46,9 +46,9 @@ void foo() {
// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(promoted) : !cir.complex<!cir.float>
-// CIR-AFTER-MUL-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-MUL-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-MUL-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-MUL-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-MUL-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-MUL-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-MUL-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-MUL-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-MUL-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -107,9 +107,9 @@ void foo() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -220,9 +220,9 @@ void foo1() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) : !cir.complex<!s32i>
-// CIR-AFTER-INT: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-AFTER-INT: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-AFTER-INT: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER-INT: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER-INT: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER-INT: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR-AFTER-INT: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-AFTER-INT: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-AFTER-INT: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!s32i> -> !s32i
@@ -285,9 +285,9 @@ void foo2() {
float _Complex c = a * b;
}
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.float>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %1 : !cir.ptr<!cir.float>, !cir.float
// CIR-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -333,9 +333,9 @@ void foo3() {
// CIR-BEFORE-BASIC: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(basic) : !cir.complex<!cir.float>
-// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-BASIC: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-BASIC: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-BASIC: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -409,9 +409,9 @@ void foo3() {
// CIR-BEFORE-IMPROVED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(improved) : !cir.complex<!cir.float>
-// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-IMPROVED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-IMPROVED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-IMPROVED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -540,9 +540,9 @@ void foo3() {
// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(promoted) : !cir.complex<!cir.float>
-// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-PROMOTED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-PROMOTED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-PROMOTED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -639,9 +639,9 @@ void foo3() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -700,9 +700,9 @@ void foo4() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!s32i>
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!s32i> -> !s32i
@@ -780,9 +780,9 @@ void foo5() {
float _Complex c = a / b;
}
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.float>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -828,9 +828,9 @@ void foo6() {
// CIR-BEFORE-BASIC: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(basic) : !cir.complex<!cir.float>
-// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR-AFTER-BASIC: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-BASIC: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-BASIC: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-BASIC: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-BASIC: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -903,9 +903,9 @@ void foo6() {
// CIR-BEFORE-IMPROVED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(improved) : !cir.complex<!cir.float>
-// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR-AFTER-IMPROVED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-IMPROVED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-IMPROVED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-IMPROVED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-IMPROVED: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -1033,9 +1033,9 @@ void foo6() {
// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(promoted) : !cir.complex<!cir.float>
-// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR-AFTER-PROMOTED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-PROMOTED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-PROMOTED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-PROMOTED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-PROMOTED: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -1129,9 +1129,9 @@ void foo6() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER-FULL: %[[CONST_0:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
@@ -1189,9 +1189,9 @@ void foo7() {
// CIR-BEFORE-FULL: %{{.*}} = cir.complex.div {{.*}}, {{.*}} range(full) : !cir.complex<!s32i>
-// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-COMBINED: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
+// CIR-COMBINED: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-COMBINED: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/CodeGen/complex-plus-minus.cpp b/clang/test/CIR/CodeGen/complex-plus-minus.cpp
index 2a5e644476494..de3c1e127f0e1 100644
--- a/clang/test/CIR/CodeGen/complex-plus-minus.cpp
+++ b/clang/test/CIR/CodeGen/complex-plus-minus.cpp
@@ -11,8 +11,8 @@ void foo() {
int _Complex c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[ADD:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!s32i>
@@ -54,8 +54,8 @@ void foo2() {
float _Complex c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[ADD:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
@@ -98,10 +98,10 @@ void foo3() {
float _Complex d = (a + b) + c;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[RESULT:.*]] = cir.alloca "d" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[ADD_A_B:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
@@ -165,8 +165,8 @@ void foo4() {
int _Complex c = a - b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[SUB:.*]] = cir.complex.sub %[[TMP_A]], %[[TMP_B]] : !cir.complex<!s32i>
@@ -210,8 +210,8 @@ void foo5() {
float _Complex c = a - b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[SUB:.*]] = cir.complex.sub %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
@@ -254,10 +254,10 @@ void foo6() {
float _Complex d = (a - b) - c;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[RESULT:.*]] = cir.alloca "d" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[SUB_A_B:.*]] = cir.complex.sub %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.float>
diff --git a/clang/test/CIR/CodeGen/complex-unary.cpp b/clang/test/CIR/CodeGen/complex-unary.cpp
index ce895307d5fae..6bf1dab3b93ff 100644
--- a/clang/test/CIR/CodeGen/complex-unary.cpp
+++ b/clang/test/CIR/CodeGen/complex-unary.cpp
@@ -10,14 +10,14 @@ void foo() {
int _Complex b = ~a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-BEFORE: %[[COMPLEX_NOT:.*]] = cir.not %[[TMP]] : !cir.complex<!s32i>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!s32i> -> !s32i
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!s32i> -> !s32i
@@ -52,14 +52,14 @@ void foo2() {
float _Complex b = ~a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_NOT:.*]] = cir.not %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -94,15 +94,15 @@ void foo3() {
float _Complex b = a++;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_INC:.*]] = cir.inc %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -143,15 +143,15 @@ void foo4() {
float _Complex b = ++a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_INC:.*]] = cir.inc %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -192,15 +192,15 @@ void foo5() {
float _Complex b = a--;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_DEC:.*]] = cir.dec %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -241,15 +241,15 @@ void foo6() {
float _Complex b = --a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_DEC:.*]] = cir.dec %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -290,13 +290,13 @@ void foo7() {
float _Complex b = +a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -321,14 +321,14 @@ void foo8() {
float _Complex b = -a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[COMPLEX_MINUS:.*]] = cir.minus %[[TMP]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_MINUS]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
@@ -367,15 +367,15 @@ void foo9() {
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.f16>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-BEFORE: %[[A_COMPLEX_F32:.*]] = cir.cast float_complex %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.complex<!cir.float>
// CIR-BEFORE: %[[A_COMPLEX_F16:.*]] = cir.cast float_complex %[[A_COMPLEX_F32]] : !cir.complex<!cir.float> -> !cir.complex<!cir.f16>
// CIR-BEFORE: cir.store{{.*}} %[[A_COMPLEX_F16]], %[[B_ADDR]] : !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.f16>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
@@ -422,16 +422,16 @@ void foo10() {
_Float16 _Complex b = -a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.f16>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-BEFORE: %[[A_COMPLEX_F32:.*]] = cir.cast float_complex %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.complex<!cir.float>
// CIR-BEFORE: %[[RESULT:.*]] = cir.minus %[[A_COMPLEX_F32]] : !cir.complex<!cir.float>
// CIR-BEFORE: %[[A_COMPLEX_F16:.*]] = cir.cast float_complex %[[RESULT]] : !cir.complex<!cir.float> -> !cir.complex<!cir.f16>
// CIR-BEFORE: cir.store{{.*}} %[[A_COMPLEX_F16]], %[[B_ADDR]] : !cir.complex<!cir.f16>, !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.f16>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.f16> -> !cir.f16
@@ -492,12 +492,12 @@ void complex_unary_inc_lvalue() {
}
-// CIR-BEFORE: %[[A_ADDR]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[RESULT:.*]] = cir.inc %[[TMP_A]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[RESULT]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
@@ -530,12 +530,12 @@ void complex_unary_dec_lvalue() {
--a;
}
-// CIR-BEFORE: %[[A_ADDR]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-BEFORE: %[[A_ADDR]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR-BEFORE: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-BEFORE: %[[RESULT:.*]] = cir.dec %[[TMP_A]] : !cir.complex<!cir.float>
// CIR-BEFORE: cir.store{{.*}} %[[RESULT]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR-AFTER: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR-AFTER: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR-AFTER: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
diff --git a/clang/test/CIR/CodeGen/complex.cpp b/clang/test/CIR/CodeGen/complex.cpp
index 3c4fc441f7b8a..076654e83b543 100644
--- a/clang/test/CIR/CodeGen/complex.cpp
+++ b/clang/test/CIR/CodeGen/complex.cpp
@@ -30,7 +30,7 @@ float _Complex cf2 = { 1.0f, 2.0f };
void foo() { int _Complex c = {}; }
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.zero : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -45,7 +45,7 @@ void foo() { int _Complex c = {}; }
void foo2() { int _Complex c = {1, 2}; }
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -64,7 +64,7 @@ void foo3() {
int _Complex c = {a, b};
}
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[TMP_B]] : !s32i -> !cir.complex<!s32i>
@@ -90,7 +90,7 @@ void foo4() {
int _Complex c = {1, a};
}
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!s32i>, !s32i
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[CONST_1]], %[[TMP_A]] : !s32i -> !cir.complex<!s32i>
@@ -112,7 +112,7 @@ void foo5() {
float _Complex c = {1.0f, 2.0f};
}
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -131,7 +131,7 @@ void foo6() {
float _Complex c = {a, b};
}
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[TMP_B]] : !cir.float -> !cir.complex<!cir.float>
@@ -157,7 +157,7 @@ void foo7() {
float _Complex c = {a, 2.0f};
}
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[CONST_2F:.*]] = cir.const #cir.fp<2.000000e+00> : !cir.float
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[CONST_2F]] : !cir.float -> !cir.complex<!cir.float>
@@ -195,7 +195,7 @@ void foo9(double a, double b) {
double _Complex c = __builtin_complex(a, b);
}
-// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.double>, !cir.double
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.double>, !cir.double
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[TMP_A]], %[[TMP_B]] : !cir.double -> !cir.complex<!cir.double>
@@ -221,7 +221,7 @@ void foo10() {
double *realPtr = &__real__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[REAL_PTR:.*]] = cir.complex.real_ptr %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
// LLVM: %[[COMPLEX:.*]] = alloca { double, double }, i64 1, align 8
@@ -235,7 +235,7 @@ void foo11() {
double *imagPtr = &__imag__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[IMAG_PTR:.*]] = cir.complex.imag_ptr %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.double>
// LLVM: %[[COMPLEX:.*]] = alloca { double, double }, i64 1, align 8
@@ -249,8 +249,8 @@ void foo12() {
double imag = __imag__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[INIT:.*]] = cir.alloca "imag" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "imag" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[IMAG]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -272,8 +272,8 @@ void foo13() {
double real = __real__ c;
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[INIT:.*]] = cir.alloca "real" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[COMPLEX:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "real" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.double> -> !cir.double
// CIR: cir.store{{.*}} %[[REAL]], %[[INIT]] : !cir.double, !cir.ptr<!cir.double>
@@ -311,8 +311,8 @@ void foo15() {
int _Complex b = a;
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[COMPLEX_B]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -336,7 +336,7 @@ int foo16(int _Complex a, int _Complex b) {
return __imag__ a + __imag__ b;
}
-// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[COMPLEX_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[COMPLEX_A]] : !cir.complex<!s32i> -> !s32i
// CIR: %[[COMPLEX_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -369,7 +369,7 @@ int foo17(int _Complex a, int _Complex b) {
return __real__ a + __real__ b;
}
-// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[COMPLEX_A:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[COMPLEX_A]] : !cir.complex<!s32i> -> !s32i
// CIR: %[[COMPLEX_B:.*]] = cir.load{{.*}} {{.*}} : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -548,9 +548,9 @@ void foo22(int _Complex a, int _Complex b) {
int _Complex c = (a, b);
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[COMPLEX_B]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP_B]], %[[RESULT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -577,10 +577,10 @@ void foo23(int _Complex a, int _Complex b) {
int _Complex c = _Generic(a, int _Complex: b, default: f);
}
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[COMPLEX_F:.*]] = cir.alloca "f" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_F:.*]] = cir.alloca "f" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX_B]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP]], %[[RESULT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -609,8 +609,8 @@ void foo24() {
int _Complex r = arr[1];
}
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} !cir.array<!cir.complex<!s32i> x 2> -> !cir.ptr<!cir.array<!cir.complex<!s32i> x 2>>
-// CIR: %[[RESULT:.*]] = cir.alloca "r" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} : !cir.ptr<!cir.array<!cir.complex<!s32i> x 2>>
+// CIR: %[[RESULT:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[IDX:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[RESULT_VAL:.*]] = cir.get_element %[[ARR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!cir.complex<!s32i> x 2>> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[RESULT_VAL]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -640,7 +640,7 @@ void foo25() {
template_foo<__builtin_complex(1.0, 2.0)>();
}
-// CIR: %[[INIT:.*]] = cir.alloca "C" {{.*}} init !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[INIT:.*]] = cir.alloca "C" {{.*}} init : !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.double, #cir.fp<2.000000e+00> : !cir.double> : !cir.complex<!cir.double>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
@@ -657,8 +657,8 @@ void foo26(int _Complex* a) {
int _Complex b = *a;
}
-// CIR: %[[COMPLEX_A_PTR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!cir.ptr<!cir.complex<!s32i>>>
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!cir.complex<!s32i>>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX_A:.*]] = cir.load deref {{.*}} %[[COMPLEX_A_PTR]] : !cir.ptr<!cir.ptr<!cir.complex<!s32i>>>, !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[TMP]], %[[COMPLEX_B]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -685,10 +685,10 @@ void foo27(bool cond, int _Complex a, int _Complex b) {
int _Complex c = cond ? a : b;
}
-// CIR: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[COMPLEX_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[RESULT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_COND:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[RESULT_VAL:.*]] = cir.ternary(%[[TMP_COND]], true {
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[COMPLEX_A]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -748,7 +748,7 @@ void foo28() {
int _Complex a = IntComplex();
}
-// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.zero : !cir.complex<!s32i>
// CIR: cir.store align(4) %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -766,7 +766,7 @@ void foo29() {
int _Complex a = IntComplex{};
}
-// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.zero : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
@@ -783,7 +783,7 @@ void foo30() {
float _Complex a = { 1.0f };
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[CONST_1F:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CIR: %[[CONST_0F:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[CONST_1F]], %[[CONST_0F]] : !cir.float -> !cir.complex<!cir.float>
@@ -807,8 +807,8 @@ void foo31() {
int r = __real__ w.c;
}
-// CIR: %[[W_ADDR:.*]] = cir.alloca "w" {{.*}} !rec_Wrapper -> !cir.ptr<!rec_Wrapper>
-// CIR: %[[REAL_ADDR:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[W_ADDR:.*]] = cir.alloca "w" {{.*}} : !cir.ptr<!rec_Wrapper>
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[ELEM_PTR:.*]] = cir.get_member %[[W_ADDR]][0] {name = "c"} : !cir.ptr<!rec_Wrapper> -> !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_ELEM_PTR:.*]] = cir.load{{.*}} %[[ELEM_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP_ELEM_PTR]] : !cir.complex<!s32i> -> !s32i
@@ -837,7 +837,7 @@ void foo32() {
int r = __real__ con.c;
}
-// CIR: %[[REAL_ADDR:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[ELEM_PTR:.*]] = cir.get_global @_ZN9Container1cE : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[ELEM:.*]] = cir.load{{.*}} %[[ELEM_PTR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[REAL:.*]] = cir.complex.real %[[ELEM]] : !cir.complex<!s32i> -> !s32i
@@ -856,8 +856,8 @@ void foo33(__builtin_va_list a) {
float _Complex b = __builtin_va_arg(a, float _Complex);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!rec___va_list_tag> -> !cir.ptr<!cir.ptr<!rec___va_list_tag>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!rec___va_list_tag>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.ptr<!rec___va_list_tag>, !cir.ptr<!cir.ptr<!rec___va_list_tag>>
// CIR: %[[VA_TAG:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!rec___va_list_tag>>, !cir.ptr<!rec___va_list_tag>
// CIR: %[[COMPLEX:.*]] = cir.va_arg %[[VA_TAG]] : (!cir.ptr<!rec___va_list_tag>) -> !cir.complex<!cir.float>
@@ -913,7 +913,7 @@ void foo34() {
__c11_atomic_init(&a, {1.0f, 2.0f});
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[CONST_COMPLEX:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[CONST_COMPLEX]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -931,8 +931,8 @@ void foo35() {
_Float16 real = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR: %[[REAL_ADDR:.*]] = cir.alloca "real" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca "real" {{.*}} init : !cir.ptr<!cir.f16>
// 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
@@ -968,8 +968,8 @@ void foo36() {
_Float16 imag = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR: %[[IMAG_ADDR:.*]] = cir.alloca "imag" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[IMAG_ADDR:.*]] = cir.alloca "imag" {{.*}} init : !cir.ptr<!cir.f16>
// 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
@@ -1005,8 +1005,8 @@ void foo37() {
_Complex float b = __extension__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -1031,8 +1031,8 @@ void real_on_non_glvalue() {
float b = __real__(+a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR: cir.store{{.*}} %[[RESULT_REAL]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1056,8 +1056,8 @@ void imag_on_non_glvalue() {
float b = __imag__(+a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[RESULT_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.float> -> !cir.float
// CIR: cir.store{{.*}} %[[RESULT_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1081,9 +1081,9 @@ void atomic_complex_type() {
float _Complex b = __c11_atomic_load(&a, __ATOMIC_RELAXED);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[ATOMIC_TMP_ADDR:.*]] = cir.alloca "atomic-temp" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ATOMIC_TMP_ADDR:.*]] = cir.alloca "atomic-temp" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[A_PTR:.*]] = cir.cast bitcast %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!u64i>
// CIR: %[[ATOMIC_TMP_PTR:.*]] = cir.cast bitcast %[[ATOMIC_TMP_ADDR]] : !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!u64i>
// CIR: %[[TMP_A_ATOMIC:.*]] = cir.load{{.*}} atomic(relaxed) %[[A_PTR]] : !cir.ptr<!u64i>, !u64i
@@ -1119,8 +1119,8 @@ void real_on_scalar_glvalue() {
float b = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.float -> !cir.float
// CIR: cir.store{{.*}} %[[A_REAL]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1140,8 +1140,8 @@ void imag_on_scalar_glvalue() {
float b = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.float -> !cir.float
// CIR: cir.store{{.*}} %[[A_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1159,8 +1159,8 @@ void real_on_scalar_with_type_promotion() {
_Float16 b = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.f16>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CIR: %[[TMP_A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A_F32]] : !cir.float -> !cir.float
@@ -1186,8 +1186,8 @@ void imag_on_scalar_with_type_promotion() {
_Float16 b = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.f16>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[TMP_A:.*]] = cir.load %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.f16 -> !cir.f16
// CIR: %[[A_IMAG_F16:.*]] = cir.cast floating %[[A_IMAG]] : !cir.f16 -> !cir.f16
@@ -1206,8 +1206,8 @@ void imag_on_const_scalar() {
float b = __imag__ 1.0f;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
// CIR: %[[CONST_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CIR: %[[CONST_IMAG:.*]] = cir.complex.imag %[[CONST_ONE]] : !cir.float -> !cir.float
// CIR: cir.store{{.*}} %[[CONST_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
@@ -1225,8 +1225,8 @@ void real_on_scalar_from_real_with_type_promotion() {
_Float16 b = __real__(__real__ a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.f16>
// 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
@@ -1263,8 +1263,8 @@ void real_on_scalar_from_imag_with_type_promotion() {
_Float16 b = __real__(__imag__ a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.f16> -> !cir.ptr<!cir.complex<!cir.f16>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.f16>
// 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
@@ -1298,7 +1298,7 @@ void real_on_scalar_from_imag_with_type_promotion() {
void complex_type_parameter(float _Complex a) {}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// TODO(CIR): the difference between the CIR LLVM and OGCG is because the lack of calling convention lowering,
@@ -1315,8 +1315,8 @@ void complex_type_argument() {
complex_type_parameter(a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[ARG_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_ARG:.*]] = cir.load{{.*}} %[[ARG_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1346,7 +1346,7 @@ float _Complex complex_type_return_type() {
return { 1.0f, 2.0f };
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[RET_VAL:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[RET_VAL]], %[[RET_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_RET:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1371,8 +1371,8 @@ void real_on_scalar_bool() {
bool b = __real__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.bool -> !cir.bool
// CIR: cir.store{{.*}} %[[A_REAL]], %[[B_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -1396,8 +1396,8 @@ void imag_on_scalar_bool() {
bool b = __imag__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.bool -> !cir.bool
// CIR: cir.store{{.*}} %[[A_IMAG]], %[[B_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -1415,7 +1415,7 @@ void imag_on_scalar_bool() {
void function_with_complex_default_arg(
float _Complex a = __builtin_complex(1.0f, 2.2f)) {}
-// CIR: %[[ARG_0_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ARG_0_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %{{.*}}, %[[ARG_0_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// TODO(CIR): the difference between the CIR LLVM and OGCG is because the lack of calling convention lowering,
@@ -1430,7 +1430,7 @@ void calling_function_with_default_arg() {
function_with_complex_default_arg();
}
-// CIR: %[[DEFAULT_ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[DEFAULT_ARG_ADDR:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[DEFAULT_ARG_VAL:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.200000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[DEFAULT_ARG_VAL]], %[[DEFAULT_ARG_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_DEFAULT_ARG:.*]] = cir.load{{.*}} %[[DEFAULT_ARG_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1455,7 +1455,7 @@ void calling_function_that_return_complex() {
float _Complex a = complex_type_return_type();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[RESULT:.*]] = cir.call @_Z24complex_type_return_typev() : () -> (!cir.complex<!cir.float> {llvm.noundef})
// CIR: cir.store{{.*}} %[[RESULT]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
@@ -1484,9 +1484,9 @@ void imag_literal_gnu_extension() {
int _Complex c = 3i;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX_A:.*]] = cir.const #cir.const_complex<#cir.fp<0.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[COMPLEX_A]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[COMPLEX_B:.*]] = cir.const #cir.const_complex<#cir.fp<0.000000e+00> : !cir.double, #cir.fp<3.000000e+00> : !cir.double> : !cir.complex<!cir.double>
@@ -1527,10 +1527,10 @@ void load_store_volatile() {
c = d;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_B:.*]] = cir.load volatile {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: cir.store volatile {{.*}} %[[TMP_B]], %[[A_ADDR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[TMP_D:.*]] = cir.load volatile {{.*}} %[[D_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -1585,14 +1585,14 @@ void load_store_volatile_2() {
dv = d;
}
-// CIR: %[[AV_ADDR:.*]] = cir.alloca "av" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[BV_ADDR:.*]] = cir.alloca "bv" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[CV_ADDR:.*]] = cir.alloca "cv" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[DV_ADDR:.*]] = cir.alloca "dv" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[AV_ADDR:.*]] = cir.alloca "av" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[BV_ADDR:.*]] = cir.alloca "bv" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[CV_ADDR:.*]] = cir.alloca "cv" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[DV_ADDR:.*]] = cir.alloca "dv" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: cir.store volatile {{.*}} %[[TMP_A]], %[[AV_ADDR]] : !cir.complex<!cir.double>, !cir.ptr<!cir.complex<!cir.double>>
// CIR: %[[TMP_BV:.*]] = cir.load volatile {{.*}} %[[BV_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
@@ -1664,9 +1664,9 @@ bool eq_float_complex_and_float(float _Complex a, float b) {
return a == b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1712,9 +1712,9 @@ bool eq_float_and_float_complex(float a, float _Complex b) {
return a == b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
@@ -1760,9 +1760,9 @@ bool ne_float_complex_and_float(float _Complex a, float b) {
return a != b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -1808,9 +1808,9 @@ bool ne_float_and_float_complex(float a, float _Complex b) {
return a != b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.store %[[ARG_0:.*]], %[[A_ADDR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: cir.store %[[ARG_1:.*]], %[[B_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
@@ -1858,9 +1858,9 @@ void compare_two_complex_bin_ops() {
bool c = a + b != b + a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.double>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// CIR: %[[COMPLEX_AB:.*]] = cir.complex.add %[[TMP_A]], %[[TMP_B]] : !cir.complex<!cir.double>
diff --git a/clang/test/CIR/CodeGen/compound_literal.cpp b/clang/test/CIR/CodeGen/compound_literal.cpp
index f01f2b9777a7f..c8a265c21576a 100644
--- a/clang/test/CIR/CodeGen/compound_literal.cpp
+++ b/clang/test/CIR/CodeGen/compound_literal.cpp
@@ -13,9 +13,9 @@ int foo() {
// CIR-DAG: cir.global "private" constant cir_private @[[FOO4_P:.*]] = #cir.const_record<{#cir.int<5> : !s32i, #cir.int<10> : !s32i}> : !rec_Point
// LLVM-DAG: @[[FOO4_P:.*]] = private constant %struct.Point { i32 5, i32 10 }
-// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[COMPOUND:.*]] = cir.alloca ".compoundliteral" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[COMPOUND:.*]] = cir.alloca ".compoundliteral" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VALUE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[VALUE]], %[[COMPOUND]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPOUND]] : !cir.ptr<!s32i>, !s32i
@@ -48,8 +48,8 @@ void foo2() {
int _Complex a = (int _Complex) { 1, 2};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CIR: %[[CL_ADDR:.*]] = cir.alloca ".compoundliteral" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[CL_ADDR:.*]] = cir.alloca ".compoundliteral" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[CL_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[CL_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
@@ -81,7 +81,7 @@ void foo3() {
auto a = (vi4){10, 20, 30, 40};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC:.*]] = cir.const #cir.const_vector<[#cir.int<10> : !s32i, #cir.int<20> : !s32i, #cir.int<30> : !s32i, #cir.int<40> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC]], %[[A_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -109,7 +109,7 @@ void foo4() {
}
// CIR-LABEL: @_Z4foo4v
-// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!rec_Point>
// CIR: %[[CONST:.*]] = cir.get_global @[[FOO4_P]] : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[CONST]] to %[[P]] : !cir.ptr<!rec_Point>
diff --git a/clang/test/CIR/CodeGen/concept-specialization.cpp b/clang/test/CIR/CodeGen/concept-specialization.cpp
index 6792b5d31809b..82dc33140ff1a 100644
--- a/clang/test/CIR/CodeGen/concept-specialization.cpp
+++ b/clang/test/CIR/CodeGen/concept-specialization.cpp
@@ -10,7 +10,7 @@ concept C = sizeof(T) % 2 == 0;
void concept_specialization() { bool a = C<int>; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.store {{.*}} %[[CONST_TRUE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
diff --git a/clang/test/CIR/CodeGen/constant-expr.cpp b/clang/test/CIR/CodeGen/constant-expr.cpp
index fa8fccaf6c53f..d409193e139b8 100644
--- a/clang/test/CIR/CodeGen/constant-expr.cpp
+++ b/clang/test/CIR/CodeGen/constant-expr.cpp
@@ -18,9 +18,9 @@ void calling_consteval_methods() {
a.consteval_ret_void();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_StructWithConstEval -> !cir.ptr<!rec_StructWithConstEval>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_StructWithConstEval>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store {{.*}} %[[CONST_1]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[CONST_COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
diff --git a/clang/test/CIR/CodeGen/copy-constructor.cpp b/clang/test/CIR/CodeGen/copy-constructor.cpp
index 3308dfa7defd2..7c3f2bfff68bd 100644
--- a/clang/test/CIR/CodeGen/copy-constructor.cpp
+++ b/clang/test/CIR/CodeGen/copy-constructor.cpp
@@ -13,8 +13,8 @@ struct HasScalarArrayMember {
HasScalarArrayMember::HasScalarArrayMember(const HasScalarArrayMember &) = default;
// CIR-LABEL: cir.func {{.*}} @_ZN20HasScalarArrayMemberC2ERKS_(
-// CIR-NEXT: %[[THIS:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_HasScalarArrayMember>
-// CIR-NEXT: %[[OTHER:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_HasScalarArrayMember>
+// CIR-NEXT: %[[THIS:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!rec_HasScalarArrayMember>>
+// CIR-NEXT: %[[OTHER:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!rec_HasScalarArrayMember>>
// CIR-NEXT: cir.store %arg0, %[[THIS]]
// CIR-NEXT: cir.store %arg1, %[[OTHER]]
// CIR-NEXT: %[[THIS_LOAD:.*]] = cir.load{{.*}} %[[THIS]]
diff --git a/clang/test/CIR/CodeGen/coro-task.cpp b/clang/test/CIR/CodeGen/coro-task.cpp
index d0c2fcae61e58..8d093180ae307 100644
--- a/clang/test/CIR/CodeGen/coro-task.cpp
+++ b/clang/test/CIR/CodeGen/coro-task.cpp
@@ -150,12 +150,12 @@ VoidTask silly_task() {
}
// CIR: cir.func coroutine {{.*}} @_Z10silly_taskv() -> ![[VoidTask]]
-// CIR: %[[VoidTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]]
-// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[VoidPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]]
-// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
-// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
-// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]]
+// CIR: %[[VoidTaskAddr:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<![[VoidTask]]>
+// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[VoidPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} : !cir.ptr<![[VoidPromisse]]>
+// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[SuspendAlways]]>
+// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<![[CoroHandleVoid]]>
+// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} : !cir.ptr<![[CoroHandlePromiseVoid]]>
// OGCG: %[[VoidPromisseAddr:.*]] = alloca %[[VoidPromisse]], align 1
// OGCG: %[[VoidTaskAddr:.*]] = alloca %[[VoidTask]], align 1
@@ -351,14 +351,14 @@ folly::coro::Task<int> byRef(const std::string& s) {
}
// CIR: cir.func coroutine {{.*}} @_Z5byRefRKSt6string(%[[ARG:.*]]: !cir.ptr<![[StdString]]> {{.*}}) -> ![[IntTask]]
-// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]>
-// CIR: %[[IntTaskAddr:.*]] = cir.alloca "__retval" {{.*}} ![[IntTask]]
-// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[AllocaFnUse:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<![[StdString]]>
-// CIR: %[[IntPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} ![[IntPromisse]]
-// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
-// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
-// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseInt]]
+// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<![[StdString]]>>
+// CIR: %[[IntTaskAddr:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<![[IntTask]]>
+// CIR: %[[SavedFrameAddr:.*]] = cir.alloca "__coro_frame_addr" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[AllocaFnUse:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<![[StdString]]>>
+// CIR: %[[IntPromisseAddr:.*]] = cir.alloca "__promise" {{.*}} : !cir.ptr<![[IntPromisse]]>
+// CIR: %[[SuspendAlwaysAddr:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[SuspendAlways]]>
+// CIR: %[[CoroHandleVoidAddr:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<![[CoroHandleVoid]]>
+// CIR: %[[CoroHandlePromiseAddr:.*]] = cir.alloca "agg.tmp1" {{.*}} : !cir.ptr<![[CoroHandlePromiseInt]]>
// CIR: cir.store %[[ARG]], %[[AllocaParam]] : !cir.ptr<![[StdString]]>, {{.*}}
// CIR: cir.cleanup.scope {
@@ -442,20 +442,20 @@ folly::coro::Task<void> yield1() {
// CIR: cir.func coroutine {{.*}} @_Z6yield1v() -> !rec_folly3A3Acoro3A3ATask3Cvoid3E
// Prologue allocas (still present in output)
-// CIR-DAG: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} ![[VoidTask]]
-// CIR-DAG: %[[FRAME:.*]] = cir.alloca "__coro_frame_addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR-DAG: %[[PROMISE:.*]] = cir.alloca "__promise" {{.*}} ![[VoidPromisse]]
-// CIR-DAG: %[[SUSP0:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[SuspendAlways]]
-// CIR-DAG: %[[CH_VOID0:.*]] = cir.alloca "agg.tmp0" {{.*}} ![[CoroHandleVoid]]
-// CIR-DAG: %[[CH_PROM0:.*]] = cir.alloca "agg.tmp1" {{.*}} ![[CoroHandlePromiseVoid]]
-// CIR-DAG: %[[T_ADDR:.*]] = cir.alloca "t" {{.*}} init ![[VoidTask]]
-// CIR-DAG: %[[SUSP1:.*]] = cir.alloca "ref.tmp1" {{.*}} ![[SuspendAlways]]
-// CIR-DAG: %[[AWAITER_COPY_ADDR:.*]] = cir.alloca "agg.tmp2" {{.*}} ![[VoidTask]]
-// CIR-DAG: %[[CH_VOID1:.*]] = cir.alloca "agg.tmp3" {{.*}} ![[CoroHandleVoid]]
-// CIR-DAG: %[[CH_PROM1:.*]] = cir.alloca "agg.tmp4" {{.*}} ![[CoroHandlePromiseVoid]]
-// CIR-DAG: %[[SUSP2:.*]] = cir.alloca "ref.tmp2" {{.*}} ![[SuspendAlways]]
-// CIR-DAG: %[[CH_VOID2:.*]] = cir.alloca "agg.tmp5" {{.*}} ![[CoroHandleVoid]]
-// CIR-DAG: %[[CH_PROM2:.*]] = cir.alloca "agg.tmp6" {{.*}} ![[CoroHandlePromiseVoid]]
+// CIR-DAG: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<![[VoidTask]]>
+// CIR-DAG: %[[FRAME:.*]] = cir.alloca "__coro_frame_addr" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR-DAG: %[[PROMISE:.*]] = cir.alloca "__promise" {{.*}} : !cir.ptr<![[VoidPromisse]]>
+// CIR-DAG: %[[SUSP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[SuspendAlways]]>
+// CIR-DAG: %[[CH_VOID0:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<![[CoroHandleVoid]]>
+// CIR-DAG: %[[CH_PROM0:.*]] = cir.alloca "agg.tmp1" {{.*}} : !cir.ptr<![[CoroHandlePromiseVoid]]>
+// CIR-DAG: %[[T_ADDR:.*]] = cir.alloca "t" {{.*}} init : !cir.ptr<![[VoidTask]]>
+// CIR-DAG: %[[SUSP1:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<![[SuspendAlways]]>
+// CIR-DAG: %[[AWAITER_COPY_ADDR:.*]] = cir.alloca "agg.tmp2" {{.*}} : !cir.ptr<![[VoidTask]]>
+// CIR-DAG: %[[CH_VOID1:.*]] = cir.alloca "agg.tmp3" {{.*}} : !cir.ptr<![[CoroHandleVoid]]>
+// CIR-DAG: %[[CH_PROM1:.*]] = cir.alloca "agg.tmp4" {{.*}} : !cir.ptr<![[CoroHandlePromiseVoid]]>
+// CIR-DAG: %[[SUSP2:.*]] = cir.alloca "ref.tmp2" {{.*}} : !cir.ptr<![[SuspendAlways]]>
+// CIR-DAG: %[[CH_VOID2:.*]] = cir.alloca "agg.tmp5" {{.*}} : !cir.ptr<![[CoroHandleVoid]]>
+// CIR-DAG: %[[CH_PROM2:.*]] = cir.alloca "agg.tmp6" {{.*}} : !cir.ptr<![[CoroHandlePromiseVoid]]>
// CIR: cir.cleanup.scope {
// initial_suspend + await(init)
@@ -538,8 +538,8 @@ folly::coro::Task<int> go1() {
}
// CIR: cir.func coroutine {{.*}} @_Z3go1v() {{.*}} ![[IntTask]]
-// CIR: %[[IntTaskAddr:.*]] = cir.alloca "task" {{.*}} init ![[IntTask]] -> !cir.ptr<![[IntTask]]>
-// CIR: %[[OneAddr:.*]] = cir.alloca "ref.tmp1" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[IntTaskAddr:.*]] = cir.alloca "task" {{.*}} init : !cir.ptr<![[IntTask]]>
+// CIR: %[[OneAddr:.*]] = cir.alloca "ref.tmp1" align(4) init : !cir.ptr<!s32i>
// CIR: cir.cleanup.scope {
// CIR: cir.await(init, ready : {
@@ -789,7 +789,7 @@ folly::coro::Task<int> co_return_with_dtor(int flag) {
// CIR: cir.func coroutine {{.*}} @_Z19co_return_with_dtori
-// CIR: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CIR: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} : !cir.ptr<!rec_HasDtor>
// CIR: cir.cleanup.scope {
// CIR: cir.await(init, ready : {
// CIR: }, suspend : {
@@ -851,8 +851,8 @@ folly::coro::Task<int __complex__> complex_co_await() noexcept {
// CIR: cir.func coroutine {{.*}} @_Z16complex_co_awaitv
-// CIR: %[[COMPLEX_ADDR:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_folly3A3Acoro3A3ATask3C_Complex_int3E -> !cir.ptr<!rec_folly3A3Acoro3A3ATask3C_Complex_int3E>
-// CIR: %[[RESUME_VAL_ADDR:.*]] = cir.alloca "__coawait_resume_rval" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[COMPLEX_ADDR:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_folly3A3Acoro3A3ATask3C_Complex_int3E>
+// CIR: %[[RESUME_VAL_ADDR:.*]] = cir.alloca "__coawait_resume_rval" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: cir.cleanup.scope {
// CIR: cir.await(init, ready : {
diff --git a/clang/test/CIR/CodeGen/count-of.c b/clang/test/CIR/CodeGen/count-of.c
index fa849567aadc5..f9b837fa30dd4 100644
--- a/clang/test/CIR/CodeGen/count-of.c
+++ b/clang/test/CIR/CodeGen/count-of.c
@@ -10,8 +10,8 @@ unsigned long vla_with_array_element_type_with_const_size() {
return _Countof(int[5][size]);
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} : !cir.ptr<!s64i>
// CIR: %[[CONST_5:.*]] = cir.const #cir.int<5> : !u64i
// CIR: cir.store %[[CONST_5]], %[[RET_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[RET_VAL:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!u64i>, !u64i
@@ -31,8 +31,8 @@ unsigned long vla_with_array_element_type_non_const_size() {
return _Countof(int[size][size]);
}
-// CIR: %[[REET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CIR: %[[REET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} : !cir.ptr<!s64i>
// CIR: %[[TMP_SIZE:.*]] = cir.load {{.*}} %[[SIZE_ADDR]] : !cir.ptr<!s64i>, !s64i
// CIR: %[[TMP_SIZE_U64:.*]] = cir.cast integral %[[TMP_SIZE]] : !s64i -> !u64i
// CIR: cir.store %[[TMP_SIZE_U64]], %[[RET_ADDR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp b/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp
index 325e692a879b3..b0b2d6471470e 100644
--- a/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp
+++ b/clang/test/CIR/CodeGen/ctor-alias-prev-decl.cpp
@@ -19,12 +19,12 @@ B::B() {
}
// CHECK: cir.func{{.*}} @_Z3barv()
-// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_B>
// CHECK: cir.call @_ZN1BC1Ev(%[[B]]) : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CHECK: cir.return
// CHECK: cir.func{{.*}} @_ZN1BC2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
diff --git a/clang/test/CIR/CodeGen/ctor-alias.cpp b/clang/test/CIR/CodeGen/ctor-alias.cpp
index 37ada55878a42..b4152bba9fc12 100644
--- a/clang/test/CIR/CodeGen/ctor-alias.cpp
+++ b/clang/test/CIR/CodeGen/ctor-alias.cpp
@@ -16,7 +16,7 @@ B::B() {
// OGCG: @_ZN1BC1Ev = unnamed_addr alias void (ptr), ptr @_ZN1BC2Ev
// CHECK: cir.func{{.*}} @_ZN1BC2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
@@ -37,7 +37,7 @@ void bar() {
}
// CHECK: cir.func{{.*}} @_Z3barv()
-// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_B>
// CHECK: cir.call @_ZN1BC1Ev(%[[B]]) : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CHECK: cir.return
@@ -61,7 +61,7 @@ void baz() {
}
// CHECK: cir.func{{.*}} @_ZN5StrukC2Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK: cir.return
@@ -69,7 +69,7 @@ void baz() {
// CHECK-NOT: cir.func{{.*}} @_ZN5StrukC1Ev
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukC2Ev(%[[S_ADDR]]) : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// LLVM: define linkonce_odr void @_ZN5StrukC2Ev(ptr{{.*}} %[[THIS_ARG]])
diff --git a/clang/test/CIR/CodeGen/ctor-null-init.cpp b/clang/test/CIR/CodeGen/ctor-null-init.cpp
index f05ee79b009a9..473d4071f2853 100644
--- a/clang/test/CIR/CodeGen/ctor-null-init.cpp
+++ b/clang/test/CIR/CodeGen/ctor-null-init.cpp
@@ -18,7 +18,7 @@ void test_empty_base_null_init() {
}
// CIR: cir.func {{.*}} @_Z25test_empty_base_null_initv()
-// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_B>
// CIR-NEXT: %[[A_ADDR:.*]] = cir.base_class_addr %[[B_ADDR]] : !cir.ptr<!rec_B> nonnull [0] -> !cir.ptr<!rec_A>
// LLVM: define{{.*}} @_Z25test_empty_base_null_initv()
@@ -45,7 +45,7 @@ void test_non_empty_base_null_init() {
}
// CIR: cir.func {{.*}} @_Z29test_non_empty_base_null_initv()
-// CIR: %[[TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_D -> !cir.ptr<!rec_D>
+// CIR: %[[TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_D>
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TMP]] : !cir.ptr<!rec_D> nonnull [0] -> !cir.ptr<!rec_C>
// CIR: %[[ZERO:.*]] = cir.const #cir.const_record<{#cir.int<0> : !s32i}> : !rec_C
// CIR: cir.store{{.*}} %[[ZERO]], %[[BASE]]
@@ -76,7 +76,7 @@ void test_base_chain_null_init() {
}
// CIR: cir.func {{.*}} @_Z25test_base_chain_null_initv()
-// CIR: %[[TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_G -> !cir.ptr<!rec_G>
+// CIR: %[[TMP:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_G>
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TMP]] : !cir.ptr<!rec_G> nonnull [0] -> !cir.ptr<!rec_F>
// CIR: %[[ZERO:.*]] = cir.const #cir.const_record<{#cir.zero : !rec_E}> : !rec_F
// CIR: cir.store{{.*}} %[[ZERO]], %[[BASE]]
diff --git a/clang/test/CIR/CodeGen/ctor-try-body.cpp b/clang/test/CIR/CodeGen/ctor-try-body.cpp
index 4ce798b2efde8..503be3f273c70 100644
--- a/clang/test/CIR/CodeGen/ctor-try-body.cpp
+++ b/clang/test/CIR/CodeGen/ctor-try-body.cpp
@@ -31,8 +31,8 @@ struct HasThings : Base {
}
// CIR: cir.func {{.*}}@_ZN9HasThingsC2ERK4Ctor(%[[THIS_ARG:.*]]: !cir.ptr<!rec_HasThings> {{.*}}, %[[C_ARG:.*]]: !cir.ptr<!rec_Ctor> {{.*}}) {{.*}}special_member<#cir.cxx_ctor<!rec_HasThings, custom>>{{.*}} {
-// CIR-NEXT: %[[THIS_ALLOC:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasThings> -> !cir.ptr<!cir.ptr<!rec_HasThings>>
-// CIR-NEXT: %[[C_ALLOC:.*]] = cir.alloca "c" {{.*}} init const !cir.ptr<!rec_Ctor> -> !cir.ptr<!cir.ptr<!rec_Ctor>>
+// CIR-NEXT: %[[THIS_ALLOC:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_HasThings>>
+// CIR-NEXT: %[[C_ALLOC:.*]] = cir.alloca "c" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Ctor>>
// CIR-NEXT: cir.store %[[THIS_ARG]], %[[THIS_ALLOC]] : !cir.ptr<!rec_HasThings>, !cir.ptr<!cir.ptr<!rec_HasThings>>
// CIR-NEXT: cir.store %[[C_ARG]], %[[C_ALLOC]] : !cir.ptr<!rec_Ctor>, !cir.ptr<!cir.ptr<!rec_Ctor>>
// CIR-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOC]] : !cir.ptr<!cir.ptr<!rec_HasThings>>, !cir.ptr<!rec_HasThings>
diff --git a/clang/test/CIR/CodeGen/ctor.cpp b/clang/test/CIR/CodeGen/ctor.cpp
index 5c8ee3758468e..b47de42b87935 100644
--- a/clang/test/CIR/CodeGen/ctor.cpp
+++ b/clang/test/CIR/CodeGen/ctor.cpp
@@ -17,20 +17,20 @@ void baz() {
// NYI, but when it is added this test should be updated to add a RUN
// line that passes '-mconstructor-aliases' to clang_cc1.
// CHECK: cir.func{{.*}} @_ZN5StrukC2Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_ZN5StrukC1Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
+// CHECK-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK-NEXT: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK-NEXT: cir.call @_ZN5StrukC2Ev(%[[THIS]]) : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" align(4) init !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" align(4) init : !cir.ptr<!rec_Struk>
// CHECK-NEXT: cir.call @_ZN5StrukC1Ev(%[[S_ADDR]]) : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// CHECK-NEXT: cir.return
@@ -61,7 +61,7 @@ void bar() {
// CHECK-NEXT: cir.return
// CHECK: cir.func{{.*}} @_Z3barv
-// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init !rec_VariadicStruk -> !cir.ptr<!rec_VariadicStruk>
+// CHECK-NEXT: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_VariadicStruk>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
diff --git a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
index a80256fb2be0e..657d2cf4d479e 100644
--- a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
+++ b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
@@ -28,8 +28,8 @@ void test() {
}
// CIR: cir.func {{.*}} @_ZN20out_of_line_operatorcviEv(%[[THIS_ARG:.+]]: !cir.ptr<!rec_out_of_line_operator>{{.*}}) -> (!s32i{{.*}})
-// CIR: %[[THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_out_of_line_operator> -> !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>
-// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]] : !cir.ptr<!rec_out_of_line_operator>, !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>
// CIR: %[[THIS_LOAD:.+]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>, !cir.ptr<!rec_out_of_line_operator>
// CIR: %[[CONST_123:.+]] = cir.const #cir.int<123> : !s32i
@@ -39,8 +39,8 @@ void test() {
// CIR: }
// CIR: cir.func no_inline comdat linkonce_odr @_ZNK15inline_operatorcviEv(%[[INLINE_THIS_ARG:.+]]: !cir.ptr<!rec_inline_operator>{{.*}}) -> (!s32i{{.*}})
-// CIR: %[[INLINE_THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_inline_operator> -> !cir.ptr<!cir.ptr<!rec_inline_operator>>
-// CIR: %[[INLINE_RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INLINE_THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_inline_operator>>
+// CIR: %[[INLINE_RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %[[INLINE_THIS_ARG]], %[[INLINE_THIS_ALLOCA]] : !cir.ptr<!rec_inline_operator>, !cir.ptr<!cir.ptr<!rec_inline_operator>>
// CIR: %[[INLINE_THIS_LOAD:.+]] = cir.load %[[INLINE_THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_inline_operator>>, !cir.ptr<!rec_inline_operator>
// CIR: %[[CONST_987:.+]] = cir.const #cir.int<987> : !s32i
@@ -50,7 +50,7 @@ void test() {
// CIR: }
// CIR: cir.func {{.*}} @_Z4testv()
-// CIR: %[[X_ALLOCA:.+]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X_ALLOCA:.+]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[I_ALLOCA:.+]] = cir.alloca "i" {{.*}}
// CIR: %[[O_ALLOCA:.+]] = cir.alloca "o" {{.*}}
// CIR: %[[CONST_42:.+]] = cir.const #cir.int<42> : !s32i
diff --git a/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp b/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp
index 59bbbdd65d1a7..3f386f6133560 100644
--- a/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp
+++ b/clang/test/CIR/CodeGen/cxx-rewritten-binary-operator.cpp
@@ -15,9 +15,9 @@ void cxx_rewritten_binary_operator_scalar_expr() {
bool neq = a != b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_HasOpEq -> !cir.ptr<!rec_HasOpEq>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !rec_HasOpEq -> !cir.ptr<!rec_HasOpEq>
-// CIR: %[[NEQ_ADDR:.*]] = cir.alloca "neq" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_HasOpEq>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!rec_HasOpEq>
+// CIR: %[[NEQ_ADDR:.*]] = cir.alloca "neq" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[EQ:.*]] = cir.call @_ZNK7HasOpEqeqERKS_(%[[A_ADDR]], %[[B_ADDR]]) : (!cir.ptr<!rec_HasOpEq> {{.*}}, !cir.ptr<!rec_HasOpEq> {{.*}}) -> (!cir.bool{{.*}})
// CIR: %[[NEQ:.*]] = cir.not %[[EQ]] : !cir.bool
// CIR: cir.store{{.*}} %[[NEQ]], %[[NEQ_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
diff --git a/clang/test/CIR/CodeGen/cxx-traits.cpp b/clang/test/CIR/CodeGen/cxx-traits.cpp
index 90ec7806306fe..3de80a61d9919 100644
--- a/clang/test/CIR/CodeGen/cxx-traits.cpp
+++ b/clang/test/CIR/CodeGen/cxx-traits.cpp
@@ -9,7 +9,7 @@ void expression_trait_expr() {
bool a = __is_lvalue_expr(0);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[CONST_FALSE:.*]] = cir.const #false
// CIR: cir.store {{.*}} %[[CONST_FALSE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
@@ -27,10 +27,10 @@ void type_trait_expr() {
bool d = __is_array(int);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.store {{.*}} %[[CONST_TRUE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CONST_FALSE:.*]] = cir.const #false
@@ -63,8 +63,8 @@ void array_type_trait_expr() {
unsigned long b = __array_extent(int[10][20], 1);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !u64i
// CIR: cir.store {{.*}} %[[CONST_2]], %[[A_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_20:.*]] = cir.const #cir.int<20> : !u64i
diff --git a/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp b/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp
index f4e34117add34..fd07b9729f31f 100644
--- a/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp
+++ b/clang/test/CIR/CodeGen/cxx23-explicit-object-member.cpp
@@ -34,7 +34,7 @@ int call_with_member(Adder a) {
// CIR-LABEL: cir.func{{.*}} @_ZNH5AdderclERKS_i(%arg0: !cir.ptr<!rec_Adder>
// CIR-SAME: %arg1: !s32i
-// CIR: %[[SELF_SLOT:.+]] = cir.alloca "self" {{.*}} !cir.ptr<!rec_Adder>
+// CIR: %[[SELF_SLOT:.+]] = cir.alloca "self" {{.*}} : !cir.ptr<!cir.ptr<!rec_Adder>>
// CIR: %[[SELF_PTR:.+]] = cir.load{{.*}} %[[SELF_SLOT]] : !cir.ptr<!cir.ptr<!rec_Adder>>, !cir.ptr<!rec_Adder>
// CIR: %[[BASE_PTR:.+]] = cir.get_member %[[SELF_PTR]][0] {name = "base"} : !cir.ptr<!rec_Adder> -> !cir.ptr<!s32i>
// CIR: %[[BASE:.+]] = cir.load{{.*}} %[[BASE_PTR]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/defaultarg.cpp b/clang/test/CIR/CodeGen/defaultarg.cpp
index 7c43fd43e6d37..2aa68b742e8a3 100644
--- a/clang/test/CIR/CodeGen/defaultarg.cpp
+++ b/clang/test/CIR/CodeGen/defaultarg.cpp
@@ -12,7 +12,7 @@ void foo() {
}
// CIR: cir.func {{.*}} @_Z3foov()
-// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[TMP1:.*]] = cir.const #cir.int<42>
// CIR: cir.store{{.*}} %[[TMP1]], %[[TMP0]]
// CIR: cir.call @_Z3barRKi(%[[TMP0]])
@@ -37,7 +37,7 @@ void test_ctor_defaultarg() {
}
// CIR: cir.func {{.*}} @_Z20test_ctor_defaultargv()
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: cir.call @_ZN1SC1Ei(%[[S]], %[[TWO]]) : (!cir.ptr<!rec_S> {{.*}}, !s32i {{.*}}) -> ()
diff --git a/clang/test/CIR/CodeGen/deferred-fn-defs.cpp b/clang/test/CIR/CodeGen/deferred-fn-defs.cpp
index 90570e0e18436..8bf73a8acb1b1 100644
--- a/clang/test/CIR/CodeGen/deferred-fn-defs.cpp
+++ b/clang/test/CIR/CodeGen/deferred-fn-defs.cpp
@@ -31,7 +31,7 @@ void use() {
// CIR: cir.store %[[ONE]], %[[RET_ADDR:.*]]
// CIR: cir.func{{.*}} @_ZN1S12inlineCalledEv
-// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[THREE:.*]] = cir.const #cir.int<3>
// CIR: cir.store %[[THREE]], %[[RET_ADDR:.*]]
diff --git a/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp b/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp
index 77b14adeab7e9..38ec263b85778 100644
--- a/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp
+++ b/clang/test/CIR/CodeGen/delegating-ctor-exceptions.cpp
@@ -26,7 +26,7 @@ HasDtor::HasDtor(int) {}
void force_default_ctor() { HasDtor x; }
// CIR: cir.func {{.*}} @_ZN7HasDtorC1Ev(%[[ARG0:.*]]: !cir.ptr<!rec_HasDtor>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasDtor> -> !cir.ptr<!cir.ptr<!rec_HasDtor>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_HasDtor>>
// CIR: cir.store %[[ARG0]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/CodeGen/delegating-ctor.cpp b/clang/test/CIR/CodeGen/delegating-ctor.cpp
index ed9cc0358668c..909e68f4455f6 100644
--- a/clang/test/CIR/CodeGen/delegating-ctor.cpp
+++ b/clang/test/CIR/CodeGen/delegating-ctor.cpp
@@ -15,7 +15,7 @@ struct Delegating {
Delegating::Delegating() : Delegating(0) {}
// CIR: cir.func {{.*}} @_ZN10DelegatingC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_Delegating> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Delegating> -> !cir.ptr<!cir.ptr<!rec_Delegating>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Delegating>>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -45,8 +45,8 @@ struct DelegatingWithZeroing {
DelegatingWithZeroing::DelegatingWithZeroing(int) : DelegatingWithZeroing() {}
// CIR: cir.func {{.*}} @_ZN21DelegatingWithZeroingC2Ei(%[[THIS_ARG:.*]]: !cir.ptr<!rec_DelegatingWithZeroing> {{.*}}, %[[I_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_DelegatingWithZeroing> -> !cir.ptr<!cir.ptr<!rec_DelegatingWithZeroing>>
-// CIR: %[[I_ADDR:.*]] = cir.alloca "" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_DelegatingWithZeroing>>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store{{.*}} %[[I_ARG]], %[[I_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
diff --git a/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp b/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp
index 512edce5f0b83..c1216b87c589e 100644
--- a/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp
+++ b/clang/test/CIR/CodeGen/delete-array-unsized-dtor.cpp
@@ -44,7 +44,7 @@ void test(Dtor *ptr) {
// CIR: cir.if %[[NOT_EMPTY]] {
//
// Destruct elements in reverse order.
-// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_Dtor> -> !cir.ptr<!cir.ptr<!rec_Dtor>>
+// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_Dtor>>
// CIR: cir.store %[[END]], %[[ARR_IDX]]
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[ARR_IDX]]
diff --git a/clang/test/CIR/CodeGen/delete-array.cpp b/clang/test/CIR/CodeGen/delete-array.cpp
index 71d8efe5394d5..210cfd383824f 100644
--- a/clang/test/CIR/CodeGen/delete-array.cpp
+++ b/clang/test/CIR/CodeGen/delete-array.cpp
@@ -207,7 +207,7 @@ void test_delete_array_destructed(Destructed *ptr) {
// CIR: %[[END:.*]] = cir.ptr_stride %[[PTR]], %[[NUM_ELEM]] : (!cir.ptr<!rec_Destructed>, !u64i) -> !cir.ptr<!rec_Destructed>
// CIR: %[[NOT_EMPTY:.*]] = cir.cmp ne %[[END]], %[[PTR]] : !cir.ptr<!rec_Destructed>
// CIR: cir.if %[[NOT_EMPTY]] {
-// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_Destructed> -> !cir.ptr<!cir.ptr<!rec_Destructed>>
+// CIR: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_Destructed>>
// CIR: cir.store %[[END]], %[[ARR_IDX]] : !cir.ptr<!rec_Destructed>, !cir.ptr<!cir.ptr<!rec_Destructed>>
// CIR: cir.do {
// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_Destructed>>, !cir.ptr<!rec_Destructed>
diff --git a/clang/test/CIR/CodeGen/delete-destroying.cpp b/clang/test/CIR/CodeGen/delete-destroying.cpp
index 15213902c812e..27ed405a0fe47 100644
--- a/clang/test/CIR/CodeGen/delete-destroying.cpp
+++ b/clang/test/CIR/CodeGen/delete-destroying.cpp
@@ -37,8 +37,8 @@ void test_destroying_delete(S *s) {
// responsible for destroying the object itself.
// CIR: cir.func {{.*}} @_Z22test_destroying_deleteP1S(%[[ARG:.*]]: !cir.ptr<!rec_S> {{.*}})
-// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init !cir.ptr<!rec_S>
-// CIR: %[[TAG_ADDR:.*]] = cir.alloca "destroying.delete.tag" {{.*}} !rec_std3A3Adestroying_delete_t
+// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[TAG_ADDR:.*]] = cir.alloca "destroying.delete.tag" {{.*}} : !cir.ptr<!rec_std3A3Adestroying_delete_t{{.*}}>
// CIR: cir.store %[[ARG]], %[[S_ADDR]]
// CIR: %[[S:.*]] = cir.load{{.*}} %[[S_ADDR]]
// CIR: %[[NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_S>
@@ -96,7 +96,7 @@ void test_virtual_destroying_delete(V *v) {
}
// CIR: cir.func {{.*}} @_Z30test_virtual_destroying_deleteP1V(%[[ARG:.*]]: !cir.ptr<!rec_V> {{.*}})
-// CIR: %[[V_ADDR:.*]] = cir.alloca "v" {{.*}} init !cir.ptr<!rec_V>
+// CIR: %[[V_ADDR:.*]] = cir.alloca "v" {{.*}} init : !cir.ptr<!cir.ptr<!rec_V>>
// CIR: cir.store %[[ARG]], %[[V_ADDR]]
// CIR: %[[V:.*]] = cir.load{{.*}} %[[V_ADDR]]
// CIR: %[[NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_V>
diff --git a/clang/test/CIR/CodeGen/delete.cpp b/clang/test/CIR/CodeGen/delete.cpp
index 28482152b8c0d..2d9caed53dbfa 100644
--- a/clang/test/CIR/CodeGen/delete.cpp
+++ b/clang/test/CIR/CodeGen/delete.cpp
@@ -142,7 +142,7 @@ void destroy(StructWithVirtualDestructor *x) {
}
// CIR: cir.func {{.*}} @_Z7destroyP27StructWithVirtualDestructor(%[[X_ARG:.*]]: !cir.ptr<!rec_StructWithVirtualDestructor> {{.*}})
-// CIR: %[[X_ADDR:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_StructWithVirtualDestructor>
+// CIR: %[[X_ADDR:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!rec_StructWithVirtualDestructor>>
// CIR: cir.store %[[X_ARG]], %[[X_ADDR]]
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR: %[[NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_StructWithVirtualDestructor>
diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp
index 12c60a541a5d9..b90f8bc62cb60 100644
--- a/clang/test/CIR/CodeGen/derived-to-base.cpp
+++ b/clang/test/CIR/CodeGen/derived-to-base.cpp
@@ -26,7 +26,7 @@ void f() {
}
// CIR: cir.func {{.*}} @_Z1fv()
-// CIR: %[[D:.*]] = cir.alloca "d" {{.*}} init !rec_Derived -> !cir.ptr<!rec_Derived>
+// CIR: %[[D:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!rec_Derived>
// CIR: cir.call @_ZN7DerivedC1Ev(%[[D]]) : (!cir.ptr<!rec_Derived> {{.*}}) -> ()
// CIR: %[[D_BASE:.*]] = cir.base_class_addr %[[D]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: cir.call @_ZN4Base1fEv(%[[D_BASE]]) : (!cir.ptr<!rec_Base> {{.*}}) -> ()
@@ -48,7 +48,7 @@ void callBaseUsingDerived(Derived *derived) {
// CIR: cir.func {{.*}} @_Z20callBaseUsingDerivedP7Derived(%[[DERIVED_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}})
-// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca "derived" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca "derived" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[DERIVED_ARG]], %[[DERIVED_ADDR]]
// CIR: %[[DERIVED:.*]] = cir.load{{.*}} %[[DERIVED_ADDR]]
// CIR: %[[DERIVED_BASE:.*]] = cir.base_class_addr %[[DERIVED]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
@@ -71,8 +71,8 @@ Base *returnBaseFromDerived(Derived* derived) {
}
// CIR: cir.func {{.*}} @_Z21returnBaseFromDerivedP7Derived(%[[DERIVED_ARG:.*]]: !cir.ptr<!rec_Derived> {{.*}}) -> (!cir.ptr<!rec_Base>{{.*}})
-// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca "derived" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
-// CIR: %[[BASE_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_Base> -> !cir.ptr<!cir.ptr<!rec_Base>>
+// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca "derived" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[BASE_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_Base>>
// CIR: cir.store %[[DERIVED_ARG]], %[[DERIVED_ADDR]]
// CIR: %[[DERIVED:.*]] = cir.load{{.*}} %[[DERIVED_ADDR]]
// CIR: %[[DERIVED_BASE:.*]] = cir.base_class_addr %[[DERIVED]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
diff --git a/clang/test/CIR/CodeGen/destructors.cpp b/clang/test/CIR/CodeGen/destructors.cpp
index 726290fe24910..3370e808f895b 100644
--- a/clang/test/CIR/CodeGen/destructors.cpp
+++ b/clang/test/CIR/CodeGen/destructors.cpp
@@ -62,8 +62,8 @@ void test_array_destructor() {
}
// CIR: cir.func {{.*}} @_Z21test_array_destructorv()
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_array_element x 5> -> !cir.ptr<!cir.array<!rec_array_element x 5>>
-// CIR: %[[ARR_PTR:.*]] = cir.alloca "arrayinit.temp" {{.*}} init !cir.ptr<!rec_array_element> -> !cir.ptr<!cir.ptr<!rec_array_element>>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!rec_array_element x 5>>
+// CIR: %[[ARR_PTR:.*]] = cir.alloca "arrayinit.temp" {{.*}} init : !cir.ptr<!cir.ptr<!rec_array_element>>
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!rec_array_element x 5>>
// CIR: cir.store{{.*}} %[[BEGIN]], %[[ARR_PTR]]
// CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !s64i
@@ -85,7 +85,7 @@ void test_array_destructor() {
// CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR]] : !cir.ptr<!cir.array<!rec_array_element x 5>>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[FIVE]] : (!cir.ptr<!rec_array_element>, !u64i)
-// CIR: %[[ARR_PTR:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_array_element> -> !cir.ptr<!cir.ptr<!rec_array_element>>
+// CIR: %[[ARR_PTR:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_array_element>>
// CIR: cir.store %[[END]], %[[ARR_PTR]]
// CIR: cir.do {
// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]]
diff --git a/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp b/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp
index 90135ec35173e..7afe7a01d85a4 100644
--- a/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp
+++ b/clang/test/CIR/CodeGen/dtor-alias-prev-decl.cpp
@@ -19,11 +19,11 @@ B::~B() {
}
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!rec_B>
// CHECK: cir.call @_ZN1BD1Ev(%[[B]]) nothrow : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CHECK: cir.func{{.*}} @_ZN1BD2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
diff --git a/clang/test/CIR/CodeGen/dtor-alias.cpp b/clang/test/CIR/CodeGen/dtor-alias.cpp
index b4bf60650b818..7182eef718f3e 100644
--- a/clang/test/CIR/CodeGen/dtor-alias.cpp
+++ b/clang/test/CIR/CodeGen/dtor-alias.cpp
@@ -16,7 +16,7 @@ B::~B() {
// OGCG: @_ZN1BD1Ev = unnamed_addr alias void (ptr), ptr @_ZN1BD2Ev
// CHECK: cir.func{{.*}} @_ZN1BD2Ev(%arg0: !cir.ptr<!rec_B>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_B>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]]
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
@@ -42,7 +42,7 @@ void baz() {
}
// CHECK: cir.func{{.*}} @_ZN5StrukD2Ev(%arg0: !cir.ptr<!rec_Struk>
-// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Struk> -> !cir.ptr<!cir.ptr<!rec_Struk>>
+// CHECK: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_Struk>, !cir.ptr<!cir.ptr<!rec_Struk>>
// CHECK: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_Struk>>, !cir.ptr<!rec_Struk>
// CHECK: cir.return
@@ -50,7 +50,7 @@ void baz() {
// CHECK-NOT: cir.func{{.*}} @_ZN5StrukD1Ev
// CHECK: cir.func{{.*}} @_Z3bazv()
-// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} !rec_Struk -> !cir.ptr<!rec_Struk>
+// CHECK: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_Struk>
// CHECK: cir.call @_ZN5StrukD2Ev(%[[S_ADDR]]) nothrow : (!cir.ptr<!rec_Struk> {{.*}}) -> ()
// LLVM: define linkonce_odr void @_ZN5StrukD2Ev(ptr{{.*}} %[[THIS_ARG]])
diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp
index 0a6426fd3908d..d75acd0b6d4ed 100644
--- a/clang/test/CIR/CodeGen/dtors.cpp
+++ b/clang/test/CIR/CodeGen/dtors.cpp
@@ -14,7 +14,7 @@ void test_temporary_dtor() {
}
// CIR: cir.func {{.*}} @_Z19test_temporary_dtorv()
-// CIR: %[[ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<!rec_A>
// CIR: cir.call @_ZN1AD1Ev(%[[ALLOCA]]) nothrow : (!cir.ptr<!rec_A> {{.*}}) -> ()
// LLVM: define dso_local void @_Z19test_temporary_dtorv(){{.*}}
@@ -35,8 +35,8 @@ bool make_temp(const B &) { return false; }
bool test_temp_or() { return make_temp(1) || make_temp(2); }
// CIR: cir.func{{.*}} @_Z12test_temp_orv()
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_B>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP0]], %[[ONE]])
// CIR: cir.cleanup.scope {
@@ -45,8 +45,8 @@ bool test_temp_or() { return make_temp(1) || make_temp(2); }
// CIR: %[[TRUE:.*]] = cir.const #true
// CIR: cir.yield %[[TRUE]] : !cir.bool
// CIR: }, false {
-// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP1]], %[[TWO]])
// CIR: cir.cleanup.scope {
@@ -137,15 +137,15 @@ bool test_temp_or() { return make_temp(1) || make_temp(2); }
bool test_temp_and() { return make_temp(1) && make_temp(2); }
// CIR: cir.func{{.*}} @_Z13test_temp_andv()
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_B>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP0]], %[[ONE]])
// CIR: cir.cleanup.scope {
// CIR: %[[MAKE_TEMP0:.*]] = cir.call @_Z9make_tempRK1B(%[[REF_TMP0]])
// CIR: %[[TERNARY:.*]] = cir.ternary(%[[MAKE_TEMP0]], true {
-// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2>
// CIR: cir.call @_ZN1BC2Ei(%[[REF_TMP1]], %[[TWO]])
// CIR: cir.cleanup.scope {
@@ -334,13 +334,13 @@ int test_temp_in_condition(G &obj) {
}
// CIR: cir.func {{.*}} @_Z22test_temp_in_conditionR1G(%[[ARG0:.*]]: !cir.ptr<!rec_G> {{.*}}) -> (!s32i {{.*}}) {{.*}} {
-// CIR: %[[OBJ:.*]] = cir.alloca "obj" {{.*}} init const !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[OBJ:.*]] = cir.alloca "obj" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_G>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], %[[OBJ]]
// CIR: cir.scope {
-// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_G -> !cir.ptr<!rec_G>
-// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} !rec_G -> !cir.ptr<!rec_G>
-// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_G>
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_G>
+// CIR: %[[CLEANUP_TMP:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_OBJ:.*]] = cir.load{{.*}} %[[OBJ]] : !cir.ptr<!cir.ptr<!rec_G>>, !cir.ptr<!rec_G>
// CIR: %[[COPY:.*]] = cir.call @_ZNK1G4copyEv(%[[LOAD_OBJ]]) : (!cir.ptr<!rec_G> {{.*}}) -> !rec_G
// CIR: cir.store{{.*}} %[[COPY]], %[[REF_TMP0]]
diff --git a/clang/test/CIR/CodeGen/embed-expr.c b/clang/test/CIR/CodeGen/embed-expr.c
index 5dbf3f19335e1..476b9e1be9f68 100644
--- a/clang/test/CIR/CodeGen/embed-expr.c
+++ b/clang/test/CIR/CodeGen/embed-expr.c
@@ -15,7 +15,7 @@ void embed_expr_on_scalar_with_constants() {
// CIR-DAG: cir.global "private" constant cir_private @[[EMBED_A:.*]] = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<47> : !s32i]> : !cir.array<!s32i x 3>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[ARRAY:.*]] = cir.get_global @[[EMBED_A]] : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: cir.copy %[[ARRAY]] to %[[A_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>>
@@ -34,8 +34,8 @@ void embed_expr_on_scalar_with_non_constants() {
};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[B_PTR:.*]] = cir.cast array_to_ptrdecay %[[B_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store {{.*}} %[[TMP_A]], %[[B_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/empty-union.c b/clang/test/CIR/CodeGen/empty-union.c
index f1e9534b9ab83..0ee5516581e15 100644
--- a/clang/test/CIR/CodeGen/empty-union.c
+++ b/clang/test/CIR/CodeGen/empty-union.c
@@ -18,7 +18,7 @@ void useEmpty() {
union Empty e;
}
// CIR: cir.func {{.*}}@useEmpty()
-// CIR: cir.alloca "e" align(1) !rec_Empty -> !cir.ptr<!rec_Empty>
+// CIR: cir.alloca "e" align(1) : !cir.ptr<!rec_Empty>
// LLVM: define {{.*}} void @useEmpty()
// LLVM: alloca %union.Empty, i64 1, align 1
// OGCG: define {{.*}} void @useEmpty()
@@ -28,7 +28,7 @@ void useEmptyAligned() {
union EmptyAligned e;
}
// CIR: cir.func {{.*}}@useEmptyAligned()
-// CIR: cir.alloca "e" align(16) !rec_EmptyAligned -> !cir.ptr<!rec_EmptyAligned>
+// CIR: cir.alloca "e" align(16) : !cir.ptr<!rec_EmptyAligned>
// LLVM: define {{.*}} void @useEmptyAligned()
// LLVM: alloca %union.EmptyAligned, i64 1, align 16
// OGCG: define {{.*}} void @useEmptyAligned()
diff --git a/clang/test/CIR/CodeGen/empty-union.cpp b/clang/test/CIR/CodeGen/empty-union.cpp
index 2feae0b77cbb9..ffe3ad26b8b62 100644
--- a/clang/test/CIR/CodeGen/empty-union.cpp
+++ b/clang/test/CIR/CodeGen/empty-union.cpp
@@ -40,7 +40,7 @@ void useEmpty() {
Empty e;
}
// CIR: cir.func {{.*}}@_Z8useEmptyv()
-// CIR: cir.alloca "e" align(1) !rec_Empty -> !cir.ptr<!rec_Empty>
+// CIR: cir.alloca "e" align(1) : !cir.ptr<!rec_Empty>
// LLVM: define {{.*}} void @_Z8useEmptyv()
// LLVM: alloca %union.Empty, i64 1, align 1
// OGCG: define {{.*}} void @_Z8useEmptyv()
@@ -50,7 +50,7 @@ void useEmptyAligned() {
EmptyAligned e;
}
// CIR: cir.func {{.*}}@_Z15useEmptyAlignedv()
-// CIR: cir.alloca "e" align(16) !rec_EmptyAligned -> !cir.ptr<!rec_EmptyAligned>
+// CIR: cir.alloca "e" align(16) : !cir.ptr<!rec_EmptyAligned>
// LLVM: define {{.*}} void @_Z15useEmptyAlignedv()
// LLVM: alloca %union.EmptyAligned, i64 1, align 16
// OGCG: define {{.*}} void @_Z15useEmptyAlignedv()
diff --git a/clang/test/CIR/CodeGen/fixed-point-literal.c b/clang/test/CIR/CodeGen/fixed-point-literal.c
index e61622ef720a7..4fe7e07cc5f3a 100644
--- a/clang/test/CIR/CodeGen/fixed-point-literal.c
+++ b/clang/test/CIR/CodeGen/fixed-point-literal.c
@@ -128,11 +128,11 @@ void test_sat_short_accum() {
// LLVM: void @test_sat_short_accum
// OGCG: void @test_sat_short_accum
_Sat short _Accum ssa;
- // CIR: cir.alloca "ssa" {{.*}} !s16i -> !cir.ptr<!s16i>
+ // CIR: cir.alloca "ssa" {{.*}} : !cir.ptr<!s16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
_Sat unsigned short _Accum susa;
- // CIR: cir.alloca "susa" {{.*}} !u16i -> !cir.ptr<!u16i>
+ // CIR: cir.alloca "susa" {{.*}} : !cir.ptr<!u16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
}
@@ -142,11 +142,11 @@ void test_sat_accum() {
// LLVM: void @test_sat_accum
// OGCG: void @test_sat_accum
_Sat _Accum sa;
- // CIR: cir.alloca "sa" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CIR: cir.alloca "sa" {{.*}} : !cir.ptr<!s32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
_Sat unsigned _Accum sua;
- // CIR: cir.alloca "sua" {{.*}} !u32i -> !cir.ptr<!u32i>
+ // CIR: cir.alloca "sua" {{.*}} : !cir.ptr<!u32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
}
@@ -156,11 +156,11 @@ void test_sat_long_accum() {
// LLVM: void @test_sat_long_accum
// OGCG: void @test_sat_long_accum
_Sat long _Accum sla;
- // CIR: cir.alloca "sla" {{.*}} !s64i -> !cir.ptr<!s64i>
+ // CIR: cir.alloca "sla" {{.*}} : !cir.ptr<!s64i>
// LLVM: alloca i64, i64 1, align 8
// OGCG: alloca i64, align 8
_Sat unsigned long _Accum sula;
- // CIR: cir.alloca "sula" {{.*}} !u64i -> !cir.ptr<!u64i>
+ // CIR: cir.alloca "sula" {{.*}} : !cir.ptr<!u64i>
// LLVM: alloca i64, i64 1, align 8
// OGCG: alloca i64, align 8
}
@@ -170,11 +170,11 @@ void test_sat_short_fract() {
// LLVM: void @test_sat_short_fract
// OGCG: void @test_sat_short_fract
_Sat short _Fract ssf;
- // CIR: cir.alloca "ssf" {{.*}} !s8i -> !cir.ptr<!s8i>
+ // CIR: cir.alloca "ssf" {{.*}} : !cir.ptr<!s8i>
// LLVM: alloca i8, i64 1, align 1
// OGCG: alloca i8, align 1
_Sat unsigned short _Fract susf;
- // CIR: cir.alloca "susf" {{.*}} !u8i -> !cir.ptr<!u8i>
+ // CIR: cir.alloca "susf" {{.*}} : !cir.ptr<!u8i>
// LLVM: alloca i8, i64 1, align 1
// OGCG: alloca i8, align 1
}
@@ -184,11 +184,11 @@ void test_sat_fract() {
// LLVM: void @test_sat_fract
// OGCG: void @test_sat_fract
_Sat _Fract sf;
- // CIR: cir.alloca "sf" {{.*}} !s16i -> !cir.ptr<!s16i>
+ // CIR: cir.alloca "sf" {{.*}} : !cir.ptr<!s16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
_Sat unsigned _Fract suf;
- // CIR: cir.alloca "suf" {{.*}} !u16i -> !cir.ptr<!u16i>
+ // CIR: cir.alloca "suf" {{.*}} : !cir.ptr<!u16i>
// LLVM: alloca i16, i64 1, align 2
// OGCG: alloca i16, align 2
}
@@ -198,11 +198,11 @@ void test_sat_long_fract() {
// LLVM: void @test_sat_long_fract
// OGCG: void @test_sat_long_fract
_Sat long _Fract slf;
- // CIR: cir.alloca "slf" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CIR: cir.alloca "slf" {{.*}} : !cir.ptr<!s32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
_Sat unsigned long _Fract sulf;
- // CIR: cir.alloca "sulf" {{.*}} !u32i -> !cir.ptr<!u32i>
+ // CIR: cir.alloca "sulf" {{.*}} : !cir.ptr<!u32i>
// LLVM: alloca i32, i64 1, align 4
// OGCG: alloca i32, align 4
}
diff --git a/clang/test/CIR/CodeGen/forrange.cpp b/clang/test/CIR/CodeGen/forrange.cpp
index c8534d7555628..610db867e7ad9 100644
--- a/clang/test/CIR/CodeGen/forrange.cpp
+++ b/clang/test/CIR/CodeGen/forrange.cpp
@@ -17,12 +17,12 @@ void for_range() {
// CIR: cir.func{{.*}} @_Z3endR9Container(!cir.ptr<!rec_Container>{{.*}}) -> (!cir.ptr<!rec_Element{{.*}})
// CIR: cir.func{{.*}} @_Z9for_rangev()
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_Container
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!rec_Container>
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_Container>
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !cir.ptr<!rec_Element>
-// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !cir.ptr<!rec_Element>
-// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Container>>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Element>>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Element>>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Element>>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: %[[C_REF:.*]] = cir.load{{.*}} %[[RANGE_ADDR]]
// CIR: %[[BEGIN:.*]] = cir.call @_Z5beginR9Container(%[[C_REF]])
@@ -60,12 +60,12 @@ void for_range2() {
}
// CIR: cir.func{{.*}} @_Z10for_range2v()
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C2
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.ptr<!rec_C2>
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C2>
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !cir.ptr<!rec_Element>
-// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !cir.ptr<!rec_Element>
-// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_C2>>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Element>>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Element>>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Element>>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: %[[C_REF:.*]] = cir.load{{.*}} %[[RANGE_ADDR]]
// CIR: %[[BEGIN:.*]] = cir.call @_ZN2C25beginEv(%[[C_REF]])
@@ -112,12 +112,12 @@ void for_range3() {
}
// CIR: cir.func{{.*}} @_Z10for_range3v()
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C3
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!rec_C3>
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C3>
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
-// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
-// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_C3>>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init : !cir.ptr<!rec_Iterator>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init : !cir.ptr<!rec_Iterator>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Element>>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: cir.for : cond {
// CIR: %[[ITER_NE:.*]] = cir.call @_ZNK8IteratorneERKS_(%[[BEGIN_ADDR]], %[[END_ADDR]])
@@ -143,11 +143,11 @@ void for_range4() {
// CIR: cir.func{{.*}} @_Z10for_range4v()
// CIR: cir.scope {
-// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const !cir.ptr<!rec_C3>
-// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
-// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init !rec_Iterator -> !cir.ptr<!rec_Iterator>
-// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const !cir.ptr<!rec_Element>
-// CIR: %[[HD:.*]] = cir.alloca "hd" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CIR: %[[RANGE_ADDR:.*]] = cir.alloca "__range1" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_C3>>
+// CIR: %[[BEGIN_ADDR:.*]] = cir.alloca "__begin1" {{.*}} init : !cir.ptr<!rec_Iterator>
+// CIR: %[[END_ADDR:.*]] = cir.alloca "__end1" {{.*}} init : !cir.ptr<!rec_Iterator>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "e" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Element>>
+// CIR: %[[HD:.*]] = cir.alloca "hd" {{.*}} : !cir.ptr<!rec_HasDtor>
// CIR: cir.store{{.*}} %[[C_ADDR]], %[[RANGE_ADDR]]
// CIR: cir.for : cond {
// CIR: %[[ITER_NE:.*]] = cir.call @_ZNK8IteratorneERKS_(%[[BEGIN_ADDR]], %[[END_ADDR]])
diff --git a/clang/test/CIR/CodeGen/generic-selection.c b/clang/test/CIR/CodeGen/generic-selection.c
index e061c728e141d..597e1c03b93d6 100644
--- a/clang/test/CIR/CodeGen/generic-selection.c
+++ b/clang/test/CIR/CodeGen/generic-selection.c
@@ -10,8 +10,8 @@ void foo() {
int r = _Generic(a, double: 1, float: 2, int: 3, default: 4);
}
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RES:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[RES:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[RES_VAL:.*]] = cir.const #cir.int<3> : !s32i
// CIR: cir.store{{.*}} %[[RES_VAL]], %[[RES]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/global-array-dtor.cpp b/clang/test/CIR/CodeGen/global-array-dtor.cpp
index 2cbc8395e8168..b751f202a783b 100644
--- a/clang/test/CIR/CodeGen/global-array-dtor.cpp
+++ b/clang/test/CIR/CodeGen/global-array-dtor.cpp
@@ -30,7 +30,7 @@ ArrayDtor arrDtor[16];
// CIR: %[[CONST16:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR_ARG]] : !cir.ptr<!void> -> !cir.ptr<!rec_ArrayDtor>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST16]] : (!cir.ptr<!rec_ArrayDtor>, !u64i) -> !cir.ptr<!rec_ArrayDtor>
-// CIR: %[[CUR_ADDR:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_ArrayDtor> -> !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
+// CIR: %[[CUR_ADDR:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.store %[[END]], %[[CUR_ADDR]] : !cir.ptr<!rec_ArrayDtor>, !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[CUR_ADDR]] : !cir.ptr<!cir.ptr<!rec_ArrayDtor>>, !cir.ptr<!rec_ArrayDtor>
diff --git a/clang/test/CIR/CodeGen/global-init.cpp b/clang/test/CIR/CodeGen/global-init.cpp
index e2ef9ccd11426..eabee8972e5d4 100644
--- a/clang/test/CIR/CodeGen/global-init.cpp
+++ b/clang/test/CIR/CodeGen/global-init.cpp
@@ -191,7 +191,7 @@ ArrayDtor arrDtor[16];
// CIR: %[[CONST16:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARR_ARG]] : !cir.ptr<!void> -> !cir.ptr<!rec_ArrayDtor>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST16]] : (!cir.ptr<!rec_ArrayDtor>, !u64i) -> !cir.ptr<!rec_ArrayDtor>
-// CIR: %[[CUR_ADDR:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_ArrayDtor> -> !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
+// CIR: %[[CUR_ADDR:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.store %[[END]], %[[CUR_ADDR]] : !cir.ptr<!rec_ArrayDtor>, !cir.ptr<!cir.ptr<!rec_ArrayDtor>>
// CIR: cir.do {
// CIR: %[[CUR:.*]] = cir.load %[[CUR_ADDR]] : !cir.ptr<!cir.ptr<!rec_ArrayDtor>>, !cir.ptr<!rec_ArrayDtor>
diff --git a/clang/test/CIR/CodeGen/gnu-null.cpp b/clang/test/CIR/CodeGen/gnu-null.cpp
index 6fe3fe89e67d7..29d6041fe7fee 100644
--- a/clang/test/CIR/CodeGen/gnu-null.cpp
+++ b/clang/test/CIR/CodeGen/gnu-null.cpp
@@ -10,8 +10,8 @@ void gnu_null_expr() {
int *b = __null;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s64i -> !cir.ptr<!s64i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
// CIR: cir.store {{.*}} %[[CONST_0]], %[[A_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR: %[[CONST_NULL:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/gnu-ptr-math.c b/clang/test/CIR/CodeGen/gnu-ptr-math.c
index 3067c71a6eebb..18d69e225377d 100644
--- a/clang/test/CIR/CodeGen/gnu-ptr-math.c
+++ b/clang/test/CIR/CodeGen/gnu-ptr-math.c
@@ -9,8 +9,8 @@ typedef int(*fptr)(int, double);
vptr vptr_add(vptr p) {
// CIR-LABEL: vptr_add
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -28,8 +28,8 @@ vptr vptr_add(vptr p) {
vptr vptr_sub(vptr p) {
// CIR-LABEL: vptr_sub
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-2> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -47,8 +47,8 @@ vptr vptr_sub(vptr p) {
vptr vptr_inc(vptr p) {
// CIR-LABEL: vptr_inc
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -65,8 +65,8 @@ vptr vptr_inc(vptr p) {
}
vptr vptr_dec(vptr p) {
// CIR-LABEL: vptr_dec
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -84,8 +84,8 @@ vptr vptr_dec(vptr p) {
fptr fptr_add(fptr p) {
// CIR-LABEL: fptr_add
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -103,8 +103,8 @@ fptr fptr_add(fptr p) {
fptr fptr_sub(fptr p) {
// CIR-LABEL: fptr_sub
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-2> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -122,8 +122,8 @@ fptr fptr_sub(fptr p) {
fptr fptr_inc(fptr p) {
// CIR-LABEL: fptr_inc
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
@@ -139,8 +139,8 @@ fptr fptr_inc(fptr p) {
}
fptr fptr_dec(fptr p) {
// CIR-LABEL: fptr_dec
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
- // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
+ // CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.double) -> !s32i>>
// CIR: %[[OFFSET:.*]] = cir.const #cir.int<-1> : !s32i
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[ARG_LOAD]], %[[OFFSET]]
diff --git a/clang/test/CIR/CodeGen/if.cpp b/clang/test/CIR/CodeGen/if.cpp
index e2d75eedd24b8..773e201ce8cfe 100644
--- a/clang/test/CIR/CodeGen/if.cpp
+++ b/clang/test/CIR/CodeGen/if.cpp
@@ -261,9 +261,9 @@ int if_init() {
}
// CIR: cir.func{{.*}} @_Z7if_initv() -> (!s32i{{.*}})
-// CIR: %[[RETVAL:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca {{.*}} : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[X:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca {{.*}} : !cir.ptr<!s32i>
// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !s32i
// CIR: cir.store{{.*}} %[[CONST42]], %[[X]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[X_VAL:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/implicit-return-zero.c b/clang/test/CIR/CodeGen/implicit-return-zero.c
index a2233295bbfdc..70df395016916 100644
--- a/clang/test/CIR/CodeGen/implicit-return-zero.c
+++ b/clang/test/CIR/CodeGen/implicit-return-zero.c
@@ -18,7 +18,7 @@ int main(void) {
}
// CIR-LABEL: cir.func{{.*}} @main
-// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[LOAD:.*]] = cir.load %[[RET]] : !cir.ptr<!s32i>, !s32i
@@ -51,7 +51,7 @@ int main(void) {
}
// CIR-LABEL: cir.func{{.*}} @main
-// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.if
diff --git a/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp b/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
index 0c87bdaa99f52..58b1551a6e85d 100644
--- a/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
+++ b/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
@@ -12,7 +12,7 @@ void test(void *p) {
}
// CIR: cir.func{{.*}} @_Z4testPv
-// CIR-NEXT: %[[P:.*]] = cir.alloca "p" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR-NEXT: %[[P:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: cir.store %arg0, %[[P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: %[[P1:.*]] = cir.load align(8) %[[P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR-NEXT: %[[P2:.*]] = cir.cast bitcast %[[P1]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
@@ -37,7 +37,7 @@ void test(void *p) {
void test_complex(void *p) { new (p) int _Complex(); }
// CIR: cir.func{{.*}} @_Z12test_complexPv
-// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: cir.store %[[ARG_0:.*]], %[[P_ADDR:.*]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[TMP_P:.*]] = cir.load {{.*}} %[[P_ADDR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[P_COMPLEX:.*]] = cir.cast bitcast %[[TMP_P:.*]] : !cir.ptr<!void> -> !cir.ptr<!cir.complex<!s32i>>
diff --git a/clang/test/CIR/CodeGen/inherited-ctors.cpp b/clang/test/CIR/CodeGen/inherited-ctors.cpp
index 60c47d752e59f..1a5a3eb6f8479 100644
--- a/clang/test/CIR/CodeGen/inherited-ctors.cpp
+++ b/clang/test/CIR/CodeGen/inherited-ctors.cpp
@@ -43,8 +43,8 @@ void fallsthrough() {
//
//
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN7DerivedCI24BaseEi(%{{.*}}: !cir.ptr<!rec_Derived>{{.*}}, %{{.*}}: !s32i{{.*}}) special_member<#cir.cxx_ctor<!rec_Derived, custom>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
-// CIR: %[[INT_ALLOCA:.*]] = cir.alloca "" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[INT_ALLOCA:.*]] = cir.alloca "" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS_LOAD]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[INT:.*]] = cir.load align(4) %[[INT_ALLOCA]] : !cir.ptr<!s32i>, !s32i
@@ -67,7 +67,7 @@ void fallsthrough() {
// LLVM-LABEL: declare void @_ZN4BaseC2Efz(ptr {{.*}}, float {{.*}}, ...)
//
// CIR-LABEL: cir.func no_inline dso_local @_Z26cannotEmitDelegateCallArgsv()
-// CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "tmp" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "tmp" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: %[[FP_1_1:.*]] = cir.const #cir.fp<1.1{{.*}}> : !cir.float
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: %[[THREE:.*]] = cir.const #cir.fp<3.0{{.*}}> : !cir.double
@@ -81,8 +81,8 @@ void fallsthrough() {
// LLVM: call void (ptr, float, ...) @_ZN4BaseC2Efz(ptr {{.*}}%[[TMP_LOAD]], float {{.*}}1.100000e+00, i32 {{.*}}2, double {{.*}}3.000000e+00)
//
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN11VirtDerivedCI24BaseEi(%{{.*}}: !cir.ptr<!rec_VirtDerived> {{.*}}, %{{.*}}: !cir.ptr<!cir.ptr<!void>>{{.*}}) special_member<#cir.cxx_ctor<!rec_VirtDerived, custom>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_VirtDerived> -> !cir.ptr<!cir.ptr<!rec_VirtDerived>>
-// CIR: %[[VTT_ALLOCA:.]] = cir.alloca "vtt" align(8) init !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_VirtDerived>>
+// CIR: %[[VTT_ALLOCA:.]] = cir.alloca "vtt" align(8) init : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtDerived>>, !cir.ptr<!rec_VirtDerived>
// CIR: %[[VTT:.*]] = cir.load align(8) %[[VTT_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[VTT_ADDR:.*]] = cir.vtt.address_point %[[VTT]] : !cir.ptr<!cir.ptr<!void>>, offset = 0 -> !cir.ptr<!cir.ptr<!void>>
@@ -101,8 +101,8 @@ void fallsthrough() {
//
//
// CIR-LABEL: cir.func no_inline comdat linkonce_odr @_ZN21VirtualDelegatingCtorC1Ei(%{{.*}}: !cir.ptr<!rec_VirtualDelegatingCtor> {{.*}}, %{{.*}}: !s32i {{.*}}) special_member<#cir.cxx_ctor<!rec_VirtualDelegatingCtor, custom>>
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_VirtualDelegatingCtor> -> !cir.ptr<!cir.ptr<!rec_VirtualDelegatingCtor>>
-// CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_VirtualDelegatingCtor>>
+// CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtualDelegatingCtor>>, !cir.ptr<!rec_VirtualDelegatingCtor>
// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS_LOAD]] : !cir.ptr<!rec_VirtualDelegatingCtor> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/init-list-lvalue.cpp b/clang/test/CIR/CodeGen/init-list-lvalue.cpp
index 47be623c4b29f..9adb6d9b872de 100644
--- a/clang/test/CIR/CodeGen/init-list-lvalue.cpp
+++ b/clang/test/CIR/CodeGen/init-list-lvalue.cpp
@@ -14,8 +14,8 @@ void test1(int i) {
// CIR: cir.func {{.*}}@_Z5test1i(%[[I_ARG:.*]]: {{.*}})
// LLVM: define {{.*}}void @_Z5test1i(i32 {{.*}}%[[I_ARG:.*]])
int &refI = {i};
- // CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[REFI_ALLOCA:.*]] = cir.alloca "refI" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[REFI_ALLOCA:.*]] = cir.alloca "refI" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.store %[[I_ARG]], %[[I_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store {{.*}}%[[I_ALLOCA]], %[[REFI_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// LLVM: %[[I_ALLOCA:.*]] = alloca i32
@@ -29,8 +29,8 @@ void test2() {
// LLVM-LABEL: define {{.*}}void @_Z5test2v()
Struct s {1, "asdf"};
Struct &refS = {s};
- // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" {{.*}} init !rec_Struct -> !cir.ptr<!rec_Struct>
- // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca "refS" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
+ // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_Struct>
+ // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca "refS" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: %[[GET_S_INIT:.*]] = cir.get_global @__const._Z5test2v.s : !cir.ptr<!rec_Struct>
// CIR: cir.copy %[[GET_S_INIT]] to %[[S_ALLOCA]] : !cir.ptr<!rec_Struct> loc(#loc33)
// CIR: cir.store {{.*}}%[[S_ALLOCA]], %[[REFS_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
@@ -47,8 +47,8 @@ void test3(Struct &s) {
// LLVM: define dso_local void @_Z5test3R6Struct(ptr{{.*}}%[[S_ARG:.*]])
using refSTy = Struct &;
Struct &refS = refSTy{s};
- // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
- // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca "refS" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
+ // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Struct>>
+ // CIR: %[[REFS_ALLOCA:.*]] = cir.alloca "refS" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: cir.store %[[S_ARG]], %[[S_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: %[[S_LOAD:.*]] = cir.load %[[S_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Struct>>, !cir.ptr<!rec_Struct>
// CIR: cir.store {{.*}}%[[S_LOAD]], %[[REFS_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
@@ -65,8 +65,8 @@ void test4() {
Struct s;
auto& [sb1, sb2] {s};
- // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" align(8) !rec_Struct -> !cir.ptr<!rec_Struct>
- // CIR: %[[SB_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_Struct> -> !cir.ptr<!cir.ptr<!rec_Struct>>
+ // CIR: %[[S_ALLOCA:.*]] = cir.alloca "s" align(8) : !cir.ptr<!rec_Struct>
+ // CIR: %[[SB_ALLOCA:.*]] = cir.alloca "" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Struct>>
// CIR: cir.store {{.*}}%[[S_ALLOCA]], %[[SB_ALLOCA]] : !cir.ptr<!rec_Struct>, !cir.ptr<!cir.ptr<!rec_Struct>>
// LLVM: %[[S_ALLOCA:.*]] = alloca %struct.Struct
// LLVM: %[[SB_ALLOCA:.*]] = alloca ptr
diff --git a/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp b/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp
index bacb207ffc842..81678a3c71e87 100644
--- a/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp
+++ b/clang/test/CIR/CodeGen/initializer-list-two-pointers.cpp
@@ -16,8 +16,8 @@ void initalizer_list_with_two_pointers_layout() {
std::initializer_list<int> a = {10, 20, 30};
}
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_std3A3Ainitializer_list3Cint3E -> !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!cir.array<!s32i x 3>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>
// CIR: %[[ARR_PTR:.*]] = cir.cast array_to_ptrdecay %[[ARR_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: %[[CONST_S32_10:.*]] = cir.const #cir.int<10> : !s32i
// CIR: cir.store {{.*}} %[[CONST_S32_10]], %[[ARR_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/inline-asm.c b/clang/test/CIR/CodeGen/inline-asm.c
index 2ccb86adc69e3..704f59f0f2f4c 100644
--- a/clang/test/CIR/CodeGen/inline-asm.c
+++ b/clang/test/CIR/CodeGen/inline-asm.c
@@ -38,7 +38,7 @@ void empty2() {
}
// CIR: cir.func{{.*}}@empty3
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[X]] : !cir.ptr<!s32i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -52,7 +52,7 @@ void empty3(int x) {
}
// CIR: cir.func{{.*}}@empty4
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [%[[X]] : !cir.ptr<!s32i> (maybe_memory)],
@@ -66,7 +66,7 @@ void empty4(int x) {
}
// CIR: cir.func{{.*}}@empty5
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[X]] : !cir.ptr<!s32i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -80,7 +80,7 @@ void empty5(int x) {
}
// CIR: cir.func{{.*}}@empty6
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -97,8 +97,8 @@ void empty6(int x) {
}
// CIR: cir.func{{.*}}@add1
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -125,7 +125,7 @@ unsigned add1(unsigned int x) {
}
// CIR: cir.func{{.*}}@add2
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!u32i>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -146,7 +146,7 @@ unsigned add2(unsigned int x) {
}
// CIR: cir.func{{.*}}@add3
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!u32i>
// CIR: %[[X_LOAD:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -169,7 +169,7 @@ unsigned add3(unsigned int x) { // ((42 + x) - 1) * 2
}
// CIR: cir.func{{.*}}@add4
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[X_LOAD:.*]] = cir.load {{.*}} %[[X]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR-NEXT: cir.asm(x86_att,
// CIR-NEXT: out = [%[[X_LOAD]] : !cir.ptr<!s32i> (maybe_memory)],
@@ -186,9 +186,9 @@ void add4(int *x) {
}
// CIR: cir.func{{.*}}@add5
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} : !cir.ptr<!cir.float>
// CIR: %[[X_LOAD:.*]] = cir.load{{.*}} %[[X]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[Y_LOAD:.*]] = cir.load{{.*}} %[[Y]] : !cir.ptr<!cir.float>, !cir.float
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -216,7 +216,7 @@ float add5(float x, float y) {
}
// CIR: cir.func{{.*}}@mov
-// CIR: %[[A:.*]] = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" align(4) : !cir.ptr<!s32i>
// CIR: %[[RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [],
@@ -232,8 +232,8 @@ unsigned mov(unsigned x) {
}
// CIR: cir.func{{.*}}@t1
-// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ASM_STRUCT:.*]] = cir.alloca "__asm_result" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[ASM_STRUCT:.*]] = cir.alloca "__asm_result" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR: %[[LEN_LOAD:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -257,7 +257,7 @@ void t1(int len) {
}
// CIR: cir.func{{.*}}@t2
-// CIR: %[[T:.*]] = cir.alloca "t" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[T:.*]] = cir.alloca "t" {{.*}} init : !cir.ptr<!u64i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[T]] : !cir.ptr<!u64i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -271,8 +271,8 @@ void t2(unsigned long long t) {
}
// CIR: cir.func{{.*}}@t3
-// CIR: %[[SRC:.*]] = cir.alloca "src" {{.*}} init !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
-// CIR-NEXT: %[[TMP:.*]] = cir.alloca "temp" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[SRC:.*]] = cir.alloca "src" {{.*}} init : !cir.ptr<!cir.ptr<!u8i>>
+// CIR-NEXT: %[[TMP:.*]] = cir.alloca "temp" {{.*}} init : !cir.ptr<!u64i>
// CIR-NEXT: cir.store
// CIR-NEXT: cir.store
// CIR-NEXT: %[[SRC_LOAD:.*]] = cir.load align(8) %[[SRC]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
@@ -291,8 +291,8 @@ void t3(unsigned char *src, unsigned long long temp) {
}
// CIR: cir.func{{.*}}@t4
-// CIR: %[[A:.*]] = cir.alloca "a" align(8) !u64i -> !cir.ptr<!u64i>
-// CIR: %[[B:.*]] = cir.alloca "b" align(8) !rec_reg -> !cir.ptr<!rec_reg>
+// CIR: %[[A:.*]] = cir.alloca "a" align(8) : !cir.ptr<!u64i>
+// CIR: %[[B:.*]] = cir.alloca "b" align(8) : !cir.ptr<!rec_reg>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [%[[A]] : !cir.ptr<!u64i> (maybe_memory), %[[B]] : !cir.ptr<!rec_reg> (maybe_memory)],
@@ -310,7 +310,7 @@ void t4(void) {
}
// CIR: cir.func{{.*}}@t5
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[FUNC:.*]] = cir.get_global @t5 : !cir.ptr<!cir.func<(!s32i)>>
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -344,7 +344,7 @@ void t6(void) {
}
// CIR: cir.func{{.*}}@t7
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %0 : !cir.ptr<!s32i>, !s32i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -376,7 +376,7 @@ void t8(void) {
}
// CIR: cir.func{{.*}}@t9
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -393,7 +393,7 @@ unsigned t9(unsigned int a) {
}
// CIR: cir.func{{.*}}@t10
-// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[R_LOAD:.*]] = cir.load align(4) %[[R]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[ZERO1:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[ZERO2:.*]] = cir.const #cir.int<0> : !s32i
@@ -415,8 +415,8 @@ void t10(int r) {
}
// CIR: cir.func{{.*}}@t11
-// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init !s8i -> !cir.ptr<!s8i>
-// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} !u32i -> !cir.ptr<!u32i>
+// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init : !cir.ptr<!s8i>
+// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} : !cir.ptr<!u32i>
// CIR: %[[INPUT_LOAD:.*]] = cir.load align(1) %[[INPUT]] : !cir.ptr<!s8i>, !s8i
// CIR: %[[INPUT_CAST:.*]] = cir.cast integral %[[INPUT_LOAD]] : !s8i -> !u32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -447,8 +447,8 @@ unsigned t11(signed char input) {
}
// CIR: cir.func{{.*}}@t12
-// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} !u8i -> !cir.ptr<!u8i>
+// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} : !cir.ptr<!u8i>
// CIR: %[[INPUT_LOAD:.*]] = cir.load align(4) %[[INPUT]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -475,8 +475,8 @@ unsigned char t12(unsigned input) {
}
// CIR: cir.func{{.*}}@t13
-// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} !u8i -> !cir.ptr<!u8i>
+// CIR: %[[INPUT:.*]] = cir.alloca "input" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[OUTPUT:.*]] = cir.alloca "output" {{.*}} : !cir.ptr<!u8i>
// CIR: %[[INPUT_LOAD:.*]] = cir.load align(4) %[[INPUT]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -524,8 +524,8 @@ struct large {
};
// CIR: cir.func{{.*}}@t15
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[LARGE:.*]] = cir.alloca "P" {{.*}} init !cir.ptr<!rec_large> -> !cir.ptr<!cir.ptr<!rec_large>>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[LARGE:.*]] = cir.alloca "P" {{.*}} init : !cir.ptr<!cir.ptr<!rec_large>>
// CIR: %[[LARGE_LOAD:.*]] = cir.load deref align(8) %1 : !cir.ptr<!cir.ptr<!rec_large>>, !cir.ptr<!rec_large>
// CIR: %[[X_LOAD:.*]] = cir.load align(4) %0 : !cir.ptr<!s32i>, !s32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -549,8 +549,8 @@ unsigned long t15(int x, struct large *P) {
}
// CIR: cir.func{{.*}}@t16
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[B_LOAD:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -576,7 +576,7 @@ int t16(void) {
}
// CIR: cir.func{{.*}}@t17
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[I]] : !cir.ptr<!s32i> (maybe_memory)],
// CIR-NEXT: in = [],
@@ -591,10 +591,10 @@ void t17(void) {
}
// CIR: cir.func{{.*}}@t18
-// CIR: %[[DATA:.*]] = cir.alloca "data" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ASM_RES_VAR:.*]] = cir.alloca "__asm_result" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR: %[[DATA:.*]] = cir.alloca "data" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[ASM_RES_VAR:.*]] = cir.alloca "__asm_result" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR: %[[DATA_LOAD:.*]] = cir.load align(4) %[[DATA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -641,9 +641,9 @@ int t18(unsigned data) {
}
// CIR: cir.func{{.*}}@t19
-// CIR: %[[DATA:.*]] = cir.alloca "data" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[DATA:.*]] = cir.alloca "data" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[DATA_LOAD:.*]] = cir.load align(4) %[[DATA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
@@ -669,9 +669,9 @@ int t19(unsigned data) {
// skip t20 and t21: long double is not supported
// CIR: cir.func{{.*}}@t22
-// CIR: %[[LA:.*]] = cir.alloca "la" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[LB:.*]] = cir.alloca "lb" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[BIGRES:.*]] = cir.alloca "bigres" {{.*}} !u32i -> !cir.ptr<!u32i>
+// CIR: %[[LA:.*]] = cir.alloca "la" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[LB:.*]] = cir.alloca "lb" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[BIGRES:.*]] = cir.alloca "bigres" {{.*}} : !cir.ptr<!u32i>
// CIR: %[[LA_LOAD:.*]] = cir.load align(4) %[[LA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[LB_LOAD:.*]] = cir.load align(4) %[[LB]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -701,9 +701,9 @@ unsigned char t22(unsigned char a, unsigned char b) {
}
// CIR: cir.func{{.*}}@t23
-// CIR: %[[LA:.*]] = cir.alloca "la" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[LB:.*]] = cir.alloca "lb" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[RES:.*]] = cir.alloca "res" {{.*}} !u8i -> !cir.ptr<!u8i>
+// CIR: %[[LA:.*]] = cir.alloca "la" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[LB:.*]] = cir.alloca "lb" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[RES:.*]] = cir.alloca "res" {{.*}} : !cir.ptr<!u8i>
// CIR: %[[LA_LOAD:.*]] = cir.load align(4) %[[LA]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[LB_LOAD:.*]] = cir.load align(4) %[[LB]] : !cir.ptr<!u32i>, !u32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -733,8 +733,8 @@ unsigned char t23(unsigned char a, unsigned char b) {
}
// CIR: cir.func{{.*}}@t24
-// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} init !s8i -> !cir.ptr<!s8i>
-// CIR: %[[ADDR:.*]] = cir.alloca "addr" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s8i>
+// CIR: %[[ADDR:.*]] = cir.alloca "addr" {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[C_LOAD:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!s8i>, !s8i
// CIR: %[[C_LOAD_CAST:.*]] = cir.cast integral %[[C_LOAD]] : !s8i -> !u64i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
@@ -830,7 +830,7 @@ void t29(void) {
}
// CIR: cir.func{{.*}}@t30
-// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[LEN_LOAD:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.asm(x86_att,
// CIR-NEXT: out = [%[[LEN]] : !cir.ptr<!s32i> (maybe_memory)],
@@ -847,7 +847,7 @@ void t30(int len) {
}
// CIR: cir.func{{.*}}@t31
-// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[LEN:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[LEN_LOAD:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[LEN_LOAD2:.*]] = cir.load align(4) %[[LEN]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.asm(x86_att,
@@ -868,8 +868,8 @@ void t31(int len) {
//t32 skipped: no goto
// CIR: cir.func{{.*}}@t33
-// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[RET:.*]] = cir.alloca "ret" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[RET:.*]] = cir.alloca "ret" {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[PTR_LOAD:.*]] = cir.load align(8) %0 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
diff --git a/clang/test/CIR/CodeGen/inline-cxx-func.cpp b/clang/test/CIR/CodeGen/inline-cxx-func.cpp
index 39e798ccc25a4..ea216ad9b8422 100644
--- a/clang/test/CIR/CodeGen/inline-cxx-func.cpp
+++ b/clang/test/CIR/CodeGen/inline-cxx-func.cpp
@@ -18,8 +18,8 @@ struct S {
// OGCG: %struct.S = type { i32 }
// CIR: cir.func{{.*}} @_ZN1S10InlineFuncEv(%arg0: !cir.ptr<!rec_S> {{.*}}) -> (!s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR: %[[MEMBER_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "Member"} : !cir.ptr<!rec_S> -> !cir.ptr<!s32i>
@@ -47,7 +47,7 @@ void use() {
}
// CIR: cir.func{{.*}} @_Z3usev()
-// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_S>
// CIR: %[[RET_VAL:.*]] = cir.call @_ZN1S10InlineFuncEv(%[[S_ADDR]]) : (!cir.ptr<!rec_S> {{.*}}) -> (!s32i {{.*}})
// CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/instantiate-init.cpp b/clang/test/CIR/CodeGen/instantiate-init.cpp
index d2e1ac65ee86f..27a406818f402 100644
--- a/clang/test/CIR/CodeGen/instantiate-init.cpp
+++ b/clang/test/CIR/CodeGen/instantiate-init.cpp
@@ -24,9 +24,9 @@ void init_vec_using_initalizer_list() {
Vector vec = {0, 1, 2};
}
-// CIR: %[[VEC_ADDR:.*]] = cir.alloca "vec" {{.*}} init !rec_Vector -> !cir.ptr<!rec_Vector>
-// CIR: %[[AGG_ADDR:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3Ainitializer_list3Cint3E -> !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>
-// CIR: %[[INIT_LIST_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.array<!s32i x 3> -> !cir.ptr<!cir.array<!s32i x 3>>
+// CIR: %[[VEC_ADDR:.*]] = cir.alloca "vec" {{.*}} init : !cir.ptr<!rec_Vector>
+// CIR: %[[AGG_ADDR:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_std3A3Ainitializer_list3Cint3E>
+// CIR: %[[INIT_LIST_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[INIT_LIST_PTR:.*]] = cir.cast array_to_ptrdecay %[[INIT_LIST_ADDR]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: %[[CONST_S32_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store {{.*}} %[[CONST_S32_0]], %[[INIT_LIST_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/kr-func-promote.c b/clang/test/CIR/CodeGen/kr-func-promote.c
index cbbdada47754b..8ecb3a2092379 100644
--- a/clang/test/CIR/CodeGen/kr-func-promote.c
+++ b/clang/test/CIR/CodeGen/kr-func-promote.c
@@ -6,7 +6,7 @@
// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG
// CIR: cir.func {{.*}}@foo(%arg0: !s32i
-// CIR: %0 = cir.alloca "x" {{.*}} init !s16i -> !cir.ptr<!s16i>
+// CIR: %0 = cir.alloca "x" {{.*}} init : !cir.ptr<!s16i>
// CIR: %1 = cir.cast integral %arg0 : !s32i -> !s16i
// CIR: cir.store %1, %0 : !s16i, !cir.ptr<!s16i>
// expected-warning at +1 {{a function definition without a prototype is deprecated}}
@@ -24,7 +24,7 @@ void foo(x) short x; {}
// OGCG: store i16 %[[X]], ptr %[[X_PTR]], align 2
// CIR: cir.func{{.*}}no_proto dso_local @bar(%arg0: !cir.double
-// CIR: %0 = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CIR: %0 = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.float>
// CIR: %1 = cir.cast floating %arg0 : !cir.double -> !cir.float
// CIR: cir.store %1, %0 : !cir.float, !cir.ptr<!cir.float>
// expected-warning at +1 {{a function definition without a prototype is deprecated}}
diff --git a/clang/test/CIR/CodeGen/label-values.c b/clang/test/CIR/CodeGen/label-values.c
index 5c794a086d1e1..cd54d91a57e9a 100644
--- a/clang/test/CIR/CodeGen/label-values.c
+++ b/clang/test/CIR/CodeGen/label-values.c
@@ -12,7 +12,7 @@ void A(void) {
return;
}
// CIR: cir.func {{.*}} @A
-// CIR: [[PTR:%.*]] = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: [[PTR:%.*]] = cir.alloca "ptr" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR: [[BLOCK:%.*]] = cir.block_address <@A, "LABEL_A"> : !cir.ptr<!void>
// CIR: cir.store align(8) [[BLOCK]], [[PTR]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: [[BLOCKADD:%.*]] = cir.load align(8) [[PTR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
@@ -54,7 +54,7 @@ void B(void) {
}
// CIR: cir.func {{.*}} @B()
-// CIR: [[PTR:%.*]] = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: [[PTR:%.*]] = cir.alloca "ptr" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR: cir.br ^bb1
// CIR: ^bb1: // 2 preds: ^bb0, ^bb2
// CIR: cir.label "LABEL_B"
@@ -155,9 +155,9 @@ void D(void) {
}
// CIR: cir.func {{.*}} @D
-// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[PTR2:.*]] = cir.alloca "ptr2" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[PTR3:.*]] = cir.alloca "ptr3" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[PTR2:.*]] = cir.alloca "ptr2" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[PTR3:.*]] = cir.alloca "ptr3" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[BLK1:.*]] = cir.block_address <@D, "LABEL_A"> : !cir.ptr<!void>
// CIR: cir.store align(8) %[[BLK1]], %[[PTR]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[BLK2:.*]] = cir.block_address <@D, "LABEL_A"> : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/label.c b/clang/test/CIR/CodeGen/label.c
index 5cc53c35c31f6..0e0a18bf3e97a 100644
--- a/clang/test/CIR/CodeGen/label.c
+++ b/clang/test/CIR/CodeGen/label.c
@@ -179,7 +179,7 @@ void foo() {
// CIR: cir.func {{.*}} @foo
// CIR: cir.scope {
-// CIR: %0 = cir.alloca "agg.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %0 = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_S>
// CIR: cir.br ^bb1
// CIR: ^bb1:
// CIR: cir.label "label"
diff --git a/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp b/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp
index d44e77c617960..b21a67e07c562 100644
--- a/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp
+++ b/clang/test/CIR/CodeGen/lambda-decomp-decl-captures.cpp
@@ -12,7 +12,7 @@ void array() {
[=]() { return first;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_0clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FIRST_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "first"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.float>
// CIR: %[[GET_FIRST:.*]] = cir.load {{.*}}%[[FIRST_MEM]] : !cir.ptr<!cir.float>, !cir.float
@@ -25,7 +25,7 @@ void array() {
[&]() { return second;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_1clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[SECOND_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "second"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[GET_SECOND:.*]] = cir.load {{.*}}%[[SECOND_MEM]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
@@ -40,7 +40,7 @@ void array() {
[third]() { return third;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_2clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[THIRD_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "third"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.float>
// CIR: %[[GET_THIRD:.*]] = cir.load {{.*}}%[[THIRD_MEM]] : !cir.ptr<!cir.float>, !cir.float
@@ -53,7 +53,7 @@ void array() {
[&fourth]() { return fourth;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ5arrayvENK3$_3clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FOURTH_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "fourth"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!cir.float>>
// CIR: %[[GET_FOURTH:.*]] = cir.load {{.*}}%[[FOURTH_MEM]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float>
@@ -76,7 +76,7 @@ void Struct() {
[=]() { return first;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_0clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FIRST_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "first"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_FIRST:.*]] = cir.load {{.*}}%[[FIRST_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -88,7 +88,7 @@ void Struct() {
// LLVM: %[[GET_FIRST:.*]] = load i32, ptr %[[FIRST_MEM]]
[&]() { return second;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_1clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[SECOND_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "second"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_SECOND:.*]] = cir.load {{.*}}%[[SECOND_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -102,7 +102,7 @@ void Struct() {
// LLVM: %[[DEREF:.*]] = load i32, ptr %[[GET_SECOND]]
[third]() { return third;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_2clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[THIRD_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "third"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_THIRD:.*]] = cir.load {{.*}}%[[THIRD_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -114,7 +114,7 @@ void Struct() {
// LLVM: %[[GET_THIRD:.*]] = load i32, ptr %[[THIRD_MEM]]
[&fourth]() { return fourth;}();
// CIR-LABEL: cir.func {{.*}}@_ZZ6StructvENK3$_3clEv
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FOURTH_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "fourth"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_FOURTH:.*]] = cir.load {{.*}}%[[FOURTH_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -135,7 +135,7 @@ void StructNested() {
auto outer = [&]() {
[=]() { return first;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FIRST_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "first"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_FIRST:.*]] = cir.load {{.*}}%[[FIRST_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -147,7 +147,7 @@ void StructNested() {
// LLVM: %[[GET_FIRST:.*]] = load i32, ptr %[[FIRST_MEM]]
[&]() { return second;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE0_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[SECOND_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "second"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_SECOND:.*]] = cir.load {{.*}}%[[SECOND_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -161,7 +161,7 @@ void StructNested() {
// LLVM: %[[DEREF:.*]] = load i32, ptr %[[GET_SECOND]]
[third]() { return third;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE1_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[THIRD_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "third"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!s32i>
// CIR: %[[LOAD_THIRD:.*]] = cir.load {{.*}}%[[THIRD_MEM]] : !cir.ptr<!s32i>, !s32i
@@ -173,7 +173,7 @@ void StructNested() {
// LLVM: %[[GET_THIRD:.*]] = load i32, ptr %[[THIRD_MEM]]
[&fourth]() { return fourth;}();
// CIR-LABEL: cir.func {{.*}}@_ZZZ12StructNestedvENK3$_0clEvENKUlvE2_clEv(
- // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[LAMBDA_TY:.*]]> -> !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>
+ // CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[LAMBDA_TY:.*]]>>
// CIR: %[[LOAD_THIS:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<![[LAMBDA_TY]]>>, !cir.ptr<![[LAMBDA_TY]]>
// CIR: %[[FOURTH_MEM:.*]] = cir.get_member %[[LOAD_THIS]][0] {name = "fourth"} : !cir.ptr<![[LAMBDA_TY]]> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_FOURTH:.*]] = cir.load {{.*}}%[[FOURTH_MEM]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/lambda-dtor-field.cpp b/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
index a82cfa8847941..a67319c77733a 100644
--- a/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
+++ b/clang/test/CIR/CodeGen/lambda-dtor-field.cpp
@@ -18,7 +18,7 @@ void capture_one(S s) {
}
// CIR-LABEL: @_Z11capture_one1S
-// CIR: %[[LAM:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
+// CIR: %[[LAM:.*]] = cir.alloca "lam" {{.*}} init : !cir.ptr<!rec_anon{{.*}}>
// CIR: %[[FIELD:.*]] = cir.get_member %[[LAM]][0] {name = "s"}
// CIR: cir.call @_ZN1SC1ERKS_(%[[FIELD]],
// CIR: cir.cleanup.scope {
@@ -54,7 +54,7 @@ void capture_two(S a, S b) {
}
// CIR-LABEL: @_Z11capture_two1SS_
-// CIR: %[[LAM2:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
+// CIR: %[[LAM2:.*]] = cir.alloca "lam" {{.*}} init : !cir.ptr<!rec_anon{{.*}}>
// CIR: %[[FA:.*]] = cir.get_member %[[LAM2]][0] {name = "a"}
// CIR: cir.call @_ZN1SC1ERKS_(%[[FA]],
// CIR: cir.cleanup.scope {
@@ -107,7 +107,7 @@ void capture_mixed(int n, S s) {
}
// CIR-LABEL: @_Z13capture_mixedi1S
-// CIR: %[[LAM3:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
+// CIR: %[[LAM3:.*]] = cir.alloca "lam" {{.*}} init : !cir.ptr<!rec_anon{{.*}}>
// CIR: %[[FN:.*]] = cir.get_member %[[LAM3]][0] {name = "n"}
// CIR: cir.load
// CIR: cir.store
@@ -154,8 +154,8 @@ void capture_local() {
}
// CIR-LABEL: @_Z13capture_localv
-// CIR: %[[S4:.*]] = cir.alloca "s" {{.*}} init !rec_S
-// CIR: %[[LAM4:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
+// CIR: %[[S4:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
+// CIR: %[[LAM4:.*]] = cir.alloca "lam" {{.*}} init : !cir.ptr<!rec_anon{{.*}}>
// CIR: cir.call @_ZN1SC1Ev(%[[S4]])
// CIR: cir.cleanup.scope {
// CIR: %[[FL:.*]] = cir.get_member %[[LAM4]][0] {name = "s"}
@@ -214,8 +214,8 @@ void stmt_expr_return(bool cond) {
}
// CIR-LABEL: @_Z16stmt_expr_returnb
-// CIR: %[[LAM5:.*]] = cir.alloca "lam" {{.*}} init !rec_anon
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[LAM5:.*]] = cir.alloca "lam" {{.*}} init : !cir.ptr<!rec_anon{{.*}}>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[FA5:.*]] = cir.get_member %[[LAM5]][0] {name = "a"}
// CIR: cir.call @_ZN1SC1Ei(%[[FA5]],
// CIR: %[[TRUE:.*]] = cir.const #true
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
index d9ff90b6f9fce..16ed63aaa80de 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker-agg-return.cpp
@@ -21,9 +21,9 @@ S agg_invoker() {
// CIR-LABEL: cir.func no_inline internal private dso_local @_ZZ11agg_invokervEN3$_08__invokeEi
// CIR-SAME: (%[[I_ARG:.*]]: !s32i {{.*}}) -> !rec_S
-// CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[UNUSED:.*]] = cir.alloca "unused.capture" {{.*}} !rec_anon
+// CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_S>
+// CIR: %[[UNUSED:.*]] = cir.alloca "unused.capture" {{.*}} : !cir.ptr<!rec_anon{{.*}}>
// CIR-NOT: cir.alloca {{.*}} ["agg.tmp
// CIR: cir.store %[[I_ARG]], %[[I_ALLOCA]]
// CIR: %[[I:.*]] = cir.load{{.*}} %[[I_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
index 80f8a7873e509..32deb3b0cfc4b 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
@@ -38,7 +38,7 @@ int g3() {
// lambda operator()
// CIR: cir.func no_inline lambda internal private dso_local @_ZZ2g3vENK3$_0clERKi(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G3:.*]]> {{.*}}, %[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}})
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G3]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval"
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
@@ -69,7 +69,7 @@ int g3() {
// CIR: cir.func no_inline internal private dso_local @_ZZ2g3vEN3$_08__invokeERKi(%[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}}) -> (!s32i{{.*}}) {{.*}} {
// CIR: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval"
-// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "unused.capture" {{.*}} ![[REC_LAM_G3]] -> !cir.ptr<![[REC_LAM_G3]]>
+// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "unused.capture" {{.*}} : !cir.ptr<![[REC_LAM_G3]]>
// CIR: cir.store %[[REF_I_ARG]], %[[REF_I_ALLOCA]]
// CIR: %[[REF_I:.*]] = cir.load{{.*}} %[[REF_I_ALLOCA]]
// CIR: %[[LAM_RESULT:.*]] = cir.call @_ZZ2g3vENK3$_0clERKi(%2, %3) : (!cir.ptr<![[REC_LAM_G3]]> {{.*}}, !cir.ptr<!s32i> {{.*}}) -> (!s32i{{.*}})
@@ -92,8 +92,8 @@ int g3() {
// lambda operator int (*)(int const&)()
// CIR: cir.func no_inline internal private dso_local @_ZZ2g3vENK3$_0cvPFiRKiEEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G3]]> {{.*}}) -> (!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>{{.*}}){{.*}} {
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G3]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_G3]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
// CIR: %[[INVOKER:.*]] = cir.get_global @_ZZ2g3vEN3$_08__invokeERKi : !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>
@@ -113,11 +113,11 @@ int g3() {
// In OGCG, the _ZZ2g3vENK3$_0cvPFiRKiEEv function is emitted just after the _Z2g3v function, see above.
// CIR: cir.func{{.*}} @_Z2g3v() -> (!s32i{{.*}}){{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[FN_ADDR:.*]] = cir.alloca "fn" {{.*}} init !cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
-// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_G3]] -> !cir.ptr<![[REC_LAM_G3]]>
-// CIR: %[[TASK:.*]] = cir.alloca "task" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[FN_ADDR:.*]] = cir.alloca "fn" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<(!cir.ptr<!s32i>) -> !s32i>>>
+// CIR: %[[LAM_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[REC_LAM_G3]]>
+// CIR: %[[TASK:.*]] = cir.alloca "task" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[REF_TMP1:.*]] = cir.alloca "ref.tmp1" {{.*}} init : !cir.ptr<!s32i>
// 1. Use `operator int (*)(int const&)()` to retrieve the fnptr to `__invoke()`.
// CIR: %[[OPERATOR_RESULT:.*]] = cir.call @_ZZ2g3vENK3$_0cvPFiRKiEEv(%[[LAM_ALLOCA]]){{.*}}
@@ -162,8 +162,8 @@ void use_void_lambda() {
// lambda operator()
// CIR: cir.func no_inline lambda internal private dso_local @_ZZ15use_void_lambdavENK3$_0clIiEEDaT_(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_VOID_LAMBDA:.*]]> {{.*}}, %[[X_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_VOID_LAMBDA]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: cir.store %[[X_ARG]], %[[X]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
@@ -171,8 +171,8 @@ void use_void_lambda() {
// lambda invoker
// CIR: cir.func no_inline internal private dso_local @_ZZ15use_void_lambdavEN3$_08__invokeIiEEDaT_(%[[X_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[UNUSED_CAPTURE:.*]] = cir.alloca "unused.capture" {{.*}} ![[REC_LAM_VOID_LAMBDA]] -> !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>
+// CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[UNUSED_CAPTURE:.*]] = cir.alloca "unused.capture" {{.*}} : !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>
// CIR: cir.store %[[X_ARG]], %[[X_ALLOCA]]
// CIR: %[[X:.*]] = cir.load{{.*}} %[[X_ALLOCA]]
// CIR: cir.call @_ZZ15use_void_lambdavENK3$_0clIiEEDaT_(%[[UNUSED_CAPTURE]], %[[X]]) : (!cir.ptr<![[REC_LAM_VOID_LAMBDA]]> {{.*}}, !s32i {{.*}}) -> ()
@@ -180,8 +180,8 @@ void use_void_lambda() {
// lambda operator void (*)(int)()
// CIR: cir.func no_inline internal private dso_local @_ZZ15use_void_lambdavENK3$_0cvPFDaT_EIiEEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_VOID_LAMBDA]]> {{.*}}) -> (!cir.ptr<!cir.func<(!s32i)>>{{.*}})
-// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_VOID_LAMBDA]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.func<(!s32i)>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
// CIR: %[[INVOKER:.*]] = cir.get_global @_ZZ15use_void_lambdavEN3$_08__invokeIiEEDaT_ : !cir.ptr<!cir.func<(!s32i)>>
@@ -190,8 +190,8 @@ void use_void_lambda() {
// CIR: cir.return %[[RET]]
// CIR: cir.func no_inline dso_local @_Z15use_void_lambdav()
-// CIR: %[[L_ALLOCA:.*]] = cir.alloca "L" {{.*}} ![[REC_LAM_VOID_LAMBDA]] -> !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>
-// CIR: %[[P_ALLOCA:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!cir.func<(!s32i)>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
+// CIR: %[[L_ALLOCA:.*]] = cir.alloca "L" {{.*}} : !cir.ptr<![[REC_LAM_VOID_LAMBDA]]>
+// CIR: %[[P_ALLOCA:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
// CIR: %[[LAMBDA:.*]] = cir.call @_ZZ15use_void_lambdavENK3$_0cvPFDaT_EIiEEv(%[[L_ALLOCA]])
// CIR: cir.store{{.*}} %[[LAMBDA]], %[[P_ALLOCA]]
// CIR: cir.return
diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp
index b064fb3195bbf..a682209ad54e6 100644
--- a/clang/test/CIR/CodeGen/lambda.cpp
+++ b/clang/test/CIR/CodeGen/lambda.cpp
@@ -15,7 +15,7 @@ void use_global_lambda() {
// CIR: cir.global "private" internal dso_local @global_lambda = #cir.undef : ![[REC_LAM_GLOBAL_LAMBDA:.*]] {alignment = 1 : i64}
// CIR: cir.func {{.*}} lambda internal private dso_local @_ZNK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]> {{.*}})
-// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_GLOBAL_LAMBDA]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS]]
// CIR: cir.load %[[THIS]]
//
@@ -47,13 +47,13 @@ void fn() {
}
// CIR: cir.func {{.*}} lambda internal private dso_local @_ZZ2fnvENK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_FN_A:.*]]> {{.*}})
-// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_FN_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_FN_A]]>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_FN_A]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS]]
// CIR: cir.load %[[THIS]]
// CIR: cir.return
// CIR: cir.func {{.*}} @_Z2fnv()
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} ![[REC_LAM_FN_A]] -> !cir.ptr<![[REC_LAM_FN_A]]>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<![[REC_LAM_FN_A]]>
// CIR: cir.call @_ZZ2fnvENK3$_0clEv(%[[A]])
// LLVM: define internal void @"_ZZ2fnvENK3$_0clEv"(ptr {{.*}} %[[THIS_ARG:.*]])
@@ -86,7 +86,7 @@ void l0() {
}
// CIR: cir.func {{.*}} lambda internal private dso_local @_ZZ2l0vENK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_L0_A:.*]]> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init !cir.ptr<![[REC_LAM_L0_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_L0_A]]>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<![[REC_LAM_L0_A]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[I_ADDR_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
@@ -100,8 +100,8 @@ void l0() {
// CIR: cir.return
// CIR: cir.func {{.*}} @_Z2l0v()
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init ![[REC_LAM_L0_A]] -> !cir.ptr<![[REC_LAM_L0_A]]>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<![[REC_LAM_L0_A]]>
// CIR: %[[I_ADDR:.*]] = cir.get_member %[[A]][0] {name = "i"}
// CIR: cir.store{{.*}} %[[I]], %[[I_ADDR]]
// CIR: cir.call @_ZZ2l0vENK3$_0clEv(%[[A]])
@@ -158,8 +158,8 @@ auto g() {
}
// CIR: cir.func {{.*}} @_Z1gv() -> ![[REC_LAM_G:.*]] attributes {{{.*}}nothrow} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} ![[REC_LAM_G]] -> !cir.ptr<![[REC_LAM_G]]>
-// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<![[REC_LAM_G]]>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TWELVE:.*]] = cir.const #cir.int<12> : !s32i
// CIR: cir.store{{.*}} %[[TWELVE]], %[[I_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[I_ADDR_ADDR:.*]] = cir.get_member %[[RETVAL]][0] {name = "i"} : !cir.ptr<![[REC_LAM_G]]> -> !cir.ptr<!cir.ptr<!s32i>>
@@ -200,8 +200,8 @@ auto g2() {
// Should be same as above because of NRVO
// CIR: cir.func {{.*}} @_Z2g2v() -> ![[REC_LAM_G2:.*]] attributes {{{.*}}nothrow} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} init ![[REC_LAM_G2]] -> !cir.ptr<![[REC_LAM_G2]]>
-// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} init : !cir.ptr<![[REC_LAM_G2]]>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TWELVE:.*]] = cir.const #cir.int<12> : !s32i
// CIR: cir.store{{.*}} %[[TWELVE]], %[[I_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[I_ADDR_ADDR:.*]] = cir.get_member %[[RETVAL]][0] {name = "i"} : !cir.ptr<![[REC_LAM_G2]]> -> !cir.ptr<!cir.ptr<!s32i>>
@@ -233,8 +233,8 @@ int f() {
}
// CIR:cir.func {{.*}} lambda internal private dso_local @_ZZ2g2vENK3$_0clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G2]]> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_G2]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_G2]]>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_G2]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[ONE_HUNDRED:.*]] = cir.const #cir.int<100> : !s32i
@@ -251,8 +251,8 @@ int f() {
// CIR: cir.return %[[RET]]
// CIR: cir.func {{.*}} @_Z1fv() -> (!s32i{{.*}})
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_G2]] -> !cir.ptr<![[REC_LAM_G2]]>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[REC_LAM_G2]]>
// CIR: %[[G2:.*]] = cir.call @_Z2g2v() : () -> ![[REC_LAM_G2]]
// CIR: cir.store{{.*}} %[[G2]], %[[TMP]]
// CIR: %[[RESULT:.*]] = cir.call @_ZZ2g2vENK3$_0clEv(%[[TMP]])
@@ -327,8 +327,8 @@ struct A {
// lambda operator() in foo()
// CIR: cir.func {{.*}} lambda comdat linkonce_odr @_ZZN1A3fooEvENKUlvE_clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_A:[^>]*]]> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_A]]>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_A]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
// CIR: %[[STRUCT_A:.*]] = cir.get_member %[[THIS]][0] {name = "this"}
@@ -354,9 +354,9 @@ struct A {
// A::foo()
// CIR: cir.func {{.*}} @_ZN1A3fooEv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_A> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[LAM_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_A]] -> !cir.ptr<![[REC_LAM_A]]>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[LAM_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[REC_LAM_A]]>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load deref %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[STRUCT_A:.*]] = cir.get_member %[[LAM_ADDR]][0] {name = "this"} : !cir.ptr<![[REC_LAM_A]]> -> !cir.ptr<!rec_A>
@@ -391,8 +391,8 @@ struct A {
// lambda operator() in bar()
// CIR: cir.func {{.*}} @_ZZN1A3barEvENKUlvE_clEv(%[[THIS_ARG2:.*]]: !cir.ptr<![[REC_LAM_PTR_A:[^>]*]]> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<![[REC_LAM_PTR_A]]> -> !cir.ptr<!cir.ptr<![[REC_LAM_PTR_A]]>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_PTR_A]]>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
// CIR: %[[STRUCT_A_ADDR_ADDR:.*]] = cir.get_member %[[THIS]][0] {name = "this"}
@@ -420,9 +420,9 @@ struct A {
// A::bar()
// CIR: cir.func {{.*}} @_ZN1A3barEv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_A> {{.*}}) -> (!s32i {llvm.noundef})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[LAM_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[REC_LAM_PTR_A]] -> !cir.ptr<![[REC_LAM_PTR_A]]>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[LAM_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[REC_LAM_PTR_A]]>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[A_ADDR_ADDR:.*]] = cir.get_member %[[LAM_ADDR]][0] {name = "this"} : !cir.ptr<![[REC_LAM_PTR_A]]> -> !cir.ptr<!cir.ptr<!rec_A>>
diff --git a/clang/test/CIR/CodeGen/launder.cpp b/clang/test/CIR/CodeGen/launder.cpp
index 72aacc5966cf7..f0f69d678c856 100644
--- a/clang/test/CIR/CodeGen/launder.cpp
+++ b/clang/test/CIR/CodeGen/launder.cpp
@@ -27,8 +27,8 @@ auto use_derived(Derived *d) {
return __builtin_launder(d);
}
// CIR-LABEL: cir.func{{.*}}@_Z11use_derivedP7Derived
-// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: %[[ARG_LOAD:.*]] = cir.load align(8) %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
// CIR: cir.store %[[ARG_LOAD]], %[[RET_ALLOCA]] : !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR: %[[RET:.*]] = cir.load %[[RET_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
@@ -48,8 +48,8 @@ auto use_derived(Derived *d) {
// OGCG: ret ptr %[[ARG_LOAD]]
//
// CIR-STRICT-LABEL: cir.func{{.*}}@_Z11use_derivedP7Derived
-// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
-// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_Derived>>
// CIR-STRICT: %[[LOAD_ARG:.*]] = cir.load align(8) %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_Derived>>, !cir.ptr<!rec_Derived>
// CIR-STRICT: %[[LAUNDER:.*]] = cir.launder %[[LOAD_ARG]] : !cir.ptr<!rec_Derived>
// CIR-STRICT: cir.store %[[LAUNDER]], %[[RET_ALLOCA]] : !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>
@@ -76,8 +76,8 @@ auto use_vm(VirtMem *vm) {
return __builtin_launder(vm);
}
// CIR-LABEL: cir.func {{.*}}@_Z6use_vmP7VirtMem
-// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init : !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_VirtMem>>
// CIR: cir.store %[[ARG_LOAD]], %[[RET_ALLOCA]] : !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>
// CIR: %[[RET:.*]] = cir.load %[[RET_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtMem>>, !cir.ptr<!rec_VirtMem>
// CIR: cir.return %[[RET]] : !cir.ptr<!rec_VirtMem>
@@ -96,8 +96,8 @@ auto use_vm(VirtMem *vm) {
// OGCG: ret ptr %[[ARG_LOAD]]
//
// CIR-STRICT-LABEL: cir.func {{.*}}@_Z6use_vmP7VirtMem
-// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
-// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_VirtMem> -> !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init : !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_VirtMem>>
// CIR-STRICT: %[[LOAD_ARG:.*]] = cir.load align(8) %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_VirtMem>>, !cir.ptr<!rec_VirtMem>
// CIR-STRICT: %[[LAUNDER:.*]] = cir.launder %[[LOAD_ARG]] : !cir.ptr<!rec_VirtMem>
// CIR-STRICT: cir.store %[[LAUNDER]], %[[RET_ALLOCA]] : !cir.ptr<!rec_VirtMem>, !cir.ptr<!cir.ptr<!rec_VirtMem>>
diff --git a/clang/test/CIR/CodeGen/local-vars.cpp b/clang/test/CIR/CodeGen/local-vars.cpp
index 57906d91f800f..fcd99f296b2d4 100644
--- a/clang/test/CIR/CodeGen/local-vars.cpp
+++ b/clang/test/CIR/CodeGen/local-vars.cpp
@@ -27,23 +27,23 @@ void test() {
// CIR: module
// CIR: cir.func{{.*}} @_Z4testv()
-// CIR: %[[I_PTR:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[L_PTR:.*]] = cir.alloca "l" align(8) init !s64i -> !cir.ptr<!s64i>
-// CIR: %[[F_PTR:.*]] = cir.alloca "f" align(4) init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[D_PTR:.*]] = cir.alloca "d" align(8) init !cir.double -> !cir.ptr<!cir.double>
-// CIR: %[[B1_PTR:.*]] = cir.alloca "b1" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[B2_PTR:.*]] = cir.alloca "b2" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[CI_PTR:.*]] = cir.alloca "ci" align(4) init const !s32i -> !cir.ptr<!s32i>
-// CIR: %[[CL_PTR:.*]] = cir.alloca "cl" align(8) init const !s64i -> !cir.ptr<!s64i>
-// CIR: %[[CF_PTR:.*]] = cir.alloca "cf" align(4) init const !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[CD_PTR:.*]] = cir.alloca "cd" align(8) init const !cir.double -> !cir.ptr<!cir.double>
-// CIR: %[[CB1_PTR:.*]] = cir.alloca "cb1" align(1) init const !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[CB2_PTR:.*]] = cir.alloca "cb2" align(1) init const !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[UII_PTR:.*]] = cir.alloca "uii" align(4) !s32i -> !cir.ptr<!s32i>
-// CIR: %[[UIL_PTR:.*]] = cir.alloca "uil" align(8) !s64i -> !cir.ptr<!s64i>
-// CIR: %[[UIF_PTR:.*]] = cir.alloca "uif" align(4) !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[UID_PTR:.*]] = cir.alloca "uid" align(8) !cir.double -> !cir.ptr<!cir.double>
-// CIR: %[[UIB_PTR:.*]] = cir.alloca "uib" align(1) !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[I_PTR:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
+// CIR: %[[L_PTR:.*]] = cir.alloca "l" align(8) init : !cir.ptr<!s64i>
+// CIR: %[[F_PTR:.*]] = cir.alloca "f" align(4) init : !cir.ptr<!cir.float>
+// CIR: %[[D_PTR:.*]] = cir.alloca "d" align(8) init : !cir.ptr<!cir.double>
+// CIR: %[[B1_PTR:.*]] = cir.alloca "b1" align(1) init : !cir.ptr<!cir.bool>
+// CIR: %[[B2_PTR:.*]] = cir.alloca "b2" align(1) init : !cir.ptr<!cir.bool>
+// CIR: %[[CI_PTR:.*]] = cir.alloca "ci" align(4) init const : !cir.ptr<!s32i>
+// CIR: %[[CL_PTR:.*]] = cir.alloca "cl" align(8) init const : !cir.ptr<!s64i>
+// CIR: %[[CF_PTR:.*]] = cir.alloca "cf" align(4) init const : !cir.ptr<!cir.float>
+// CIR: %[[CD_PTR:.*]] = cir.alloca "cd" align(8) init const : !cir.ptr<!cir.double>
+// CIR: %[[CB1_PTR:.*]] = cir.alloca "cb1" align(1) init const : !cir.ptr<!cir.bool>
+// CIR: %[[CB2_PTR:.*]] = cir.alloca "cb2" align(1) init const : !cir.ptr<!cir.bool>
+// CIR: %[[UII_PTR:.*]] = cir.alloca "uii" align(4) : !cir.ptr<!s32i>
+// CIR: %[[UIL_PTR:.*]] = cir.alloca "uil" align(8) : !cir.ptr<!s64i>
+// CIR: %[[UIF_PTR:.*]] = cir.alloca "uif" align(4) : !cir.ptr<!cir.float>
+// CIR: %[[UID_PTR:.*]] = cir.alloca "uid" align(8) : !cir.ptr<!cir.double>
+// CIR: %[[UIB_PTR:.*]] = cir.alloca "uib" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store align(4) %[[ONE]], %[[I_PTR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s64i
@@ -146,13 +146,13 @@ void value_init() {
}
// CIR: cir.func{{.*}} @_Z10value_initv()
-// CIR: %[[F_PTR:.+]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B_PTR:.+]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[I_PTR:.+]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[F2_PTR:.+]] = cir.alloca "f2" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[B2_PTR:.+]] = cir.alloca "b2" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[I2_PTR:.+]] = cir.alloca "i2" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[S_PTR:.+]] = cir.alloca "scalar_value_init_expr" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[F_PTR:.+]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[B_PTR:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[I_PTR:.+]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[F2_PTR:.+]] = cir.alloca "f2" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[B2_PTR:.+]] = cir.alloca "b2" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[I2_PTR:.+]] = cir.alloca "i2" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[S_PTR:.+]] = cir.alloca "scalar_value_init_expr" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[ZEROF1:.+]] = cir.const #cir.fp<0.000000e+00> : !cir.float
// CIR: cir.store{{.*}} %[[ZEROF1]], %[[F_PTR]] : !cir.float, !cir.ptr<!cir.float>
// CIR: %[[FALSE1:.+]] = cir.const #false
diff --git a/clang/test/CIR/CodeGen/long-double-inc-dec.cpp b/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
index fa2f70026452c..495a21ee352e8 100644
--- a/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
+++ b/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
@@ -21,8 +21,8 @@
extern "C" long double do_pre_inc(long double d) {
// CIR-LABEL: @do_pre_inc(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_pre_inc(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
@@ -47,8 +47,8 @@ extern "C" long double do_pre_inc(long double d) {
}
extern "C" long double do_post_inc(long double d) {
// CIR-LABEL: @do_post_inc(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_post_inc(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
@@ -74,8 +74,8 @@ extern "C" long double do_post_inc(long double d) {
extern "C" long double do_pre_dec(long double d) {
// CIR-LABEL: @do_pre_dec(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_pre_dec(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
@@ -100,8 +100,8 @@ extern "C" long double do_pre_dec(long double d) {
}
extern "C" long double do_post_dec(long double d) {
// CIR-LABEL: @do_post_dec(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} !cir.long_double<![[LDTY]]> -> !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_post_dec(
// LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp
index 37f6c2962c652..f9119278be4f6 100644
--- a/clang/test/CIR/CodeGen/loop.cpp
+++ b/clang/test/CIR/CodeGen/loop.cpp
@@ -55,7 +55,7 @@ void l1() {
// CIR: cir.func{{.*}} @_Z2l1v
// CIR-NEXT: cir.scope {
-// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[ZERO]], %[[I]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.for : cond {
@@ -108,7 +108,7 @@ void l2() {
// CIR-NEXT: cir.condition(%[[TRUE]])
// CIR-NEXT: } body {
// CIR-NEXT: cir.scope {
-// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-NEXT: cir.store{{.*}} %[[ZERO]], %[[I]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: }
@@ -153,7 +153,7 @@ void l3() {
// CIR: cir.func{{.*}} @_Z2l3v
// CIR-NEXT: cir.scope {
-// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: cir.for : cond {
// CIR-NEXT: %[[TRUE:.*]] = cir.const #true
// CIR-NEXT: cir.condition(%[[TRUE]])
@@ -507,7 +507,7 @@ void unreachable_after_continue() {
// CIR: cir.condition(%[[TRUE]])
// CIR: } body {
// CIR: cir.scope {
-// CIR: %[[X:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CIR: cir.continue
// CIR: ^bb1: // no predecessors
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -567,7 +567,7 @@ void unreachable_after_break() {
// CIR: cir.condition(%[[TRUE]])
// CIR: } body {
// CIR: cir.scope {
-// CIR: %[[X:.*]] = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CIR: cir.break
// CIR: ^bb1: // no predecessors
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
diff --git a/clang/test/CIR/CodeGen/mem-expr-fn.cpp b/clang/test/CIR/CodeGen/mem-expr-fn.cpp
index 64a5c19be959c..00a33383f60d6 100644
--- a/clang/test/CIR/CodeGen/mem-expr-fn.cpp
+++ b/clang/test/CIR/CodeGen/mem-expr-fn.cpp
@@ -12,8 +12,8 @@ struct WithStaticMem {
extern "C" void use(WithStaticMem m) {
// CIR-LABEL: use(
auto x = m.StaticMem;
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "m" {{.*}} init !rec_WithStaticMem -> !cir.ptr<!rec_WithStaticMem>
- // CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !cir.ptr<!cir.func<()>> -> !cir.ptr<!cir.ptr<!cir.func<()>>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "m" {{.*}} init : !cir.ptr<!rec_WithStaticMem>
+ // CIR: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.ptr<!cir.func<()>>>
// CIR: cir.store %{{.*}}, %[[ARG_ALLOCA]] : !rec_WithStaticMem, !cir.ptr<!rec_WithStaticMem>
// CIR: %[[GET_STATIC_FUNC:.*]] = cir.get_global @_ZN13WithStaticMem9StaticMemEv : !cir.ptr<!cir.func<()>>
// CIR: cir.store {{.*}}%[[GET_STATIC_FUNC]], %[[X_ALLOCA]] : !cir.ptr<!cir.func<()>>, !cir.ptr<!cir.ptr<!cir.func<()>>>
diff --git a/clang/test/CIR/CodeGen/member-functions.cpp b/clang/test/CIR/CodeGen/member-functions.cpp
index a63b5532f1936..8849fcbf2f99a 100644
--- a/clang/test/CIR/CodeGen/member-functions.cpp
+++ b/clang/test/CIR/CodeGen/member-functions.cpp
@@ -11,7 +11,7 @@ struct C {
void C::f() {}
// CIR: cir.func{{.*}} @_ZN1C1fEv(%[[THIS_ARG:.*]]: !cir.ptr<!rec_C>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]] : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
// CIR: cir.return
@@ -20,9 +20,9 @@ void C::f() {}
void C::f2(int a, int b) {}
// CIR: cir.func{{.*}} @_ZN1C2f2Eii(%[[THIS_ARG:.*]]: !cir.ptr<!rec_C> {{.*}}, %[[A_ARG:.*]]: !s32i {{.*}}, %[[B_ARG:.*]]: !s32i {{.*}})
-// CIR-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
-// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_C>>
+// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[THIS_ARG]], %[[THIS_ADDR]] : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
// CIR-NEXT: cir.store %[[A_ARG]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[B_ARG]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
@@ -37,7 +37,7 @@ void test1() {
}
// CIR: cir.func{{.*}} @_Z5test1v()
-// CIR-NEXT: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !rec_C -> !cir.ptr<!rec_C>
+// CIR-NEXT: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!rec_C>
// CIR-NEXT: cir.call @_ZN1C1fEv(%[[C_ADDR]]) : (!cir.ptr<!rec_C> {{.*}}) -> ()
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
diff --git a/clang/test/CIR/CodeGen/new-array-in-ternary.cpp b/clang/test/CIR/CodeGen/new-array-in-ternary.cpp
index 0a53f2f6f3e85..25fa87aa4cbb3 100644
--- a/clang/test/CIR/CodeGen/new-array-in-ternary.cpp
+++ b/clang/test/CIR/CodeGen/new-array-in-ternary.cpp
@@ -51,12 +51,12 @@ DoubleAPFloat::DoubleAPFloat()
// LLVM: ret void
// CIR-EH-LABEL: cir.func {{.*}} @_ZN13DoubleAPFloatC2Ev
-// CIR-EH: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR-EH: %[[ACTIVE:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR-EH: %[[FALSE_INIT:.*]] = cir.const #false
// CIR-EH: cir.store %[[FALSE_INIT]], %[[ACTIVE]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR-EH: %[[RESULT:.*]] = cir.ternary({{.*}}, true {
-// CIR-EH: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_APFloat> -> !cir.ptr<!cir.ptr<!rec_APFloat>>
-// CIR-EH: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.ptr<!rec_APFloat> -> !cir.ptr<!cir.ptr<!rec_APFloat>>
+// CIR-EH: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_APFloat>>
+// CIR-EH: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.ptr<!rec_APFloat>>
// CIR-EH: cir.call @_Znam
// CIR-EH: cir.cleanup.scope {
// CIR-EH: %[[TRUE:.*]] = cir.const #true
@@ -138,7 +138,7 @@ T &pickRef(bool b) {
// CIR-EH-LABEL: cir.func {{.*}} @_Z7pickRefb
// CIR-EH: %[[RES:.*]] = cir.ternary({{.*}}, true {
-// CIR-EH: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} !cir.ptr<!rec_T> -> !cir.ptr<!cir.ptr<!rec_T>>
+// CIR-EH: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.ptr<!rec_T>>
// CIR-EH: cir.call @_Znam
// CIR-EH: cir.cleanup.scope {
// CIR-EH: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/new-delete-deactivation.cpp b/clang/test/CIR/CodeGen/new-delete-deactivation.cpp
index b120a6ae656fd..7517bd70fef35 100644
--- a/clang/test/CIR/CodeGen/new-delete-deactivation.cpp
+++ b/clang/test/CIR/CodeGen/new-delete-deactivation.cpp
@@ -22,10 +22,10 @@ B makeB();
A *deact_simple() { return new A(makeB()); }
// CIR-LABEL: cir.func {{.*}} @_Z12deact_simplev() -> !cir.ptr<!rec_A>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_B -> !cir.ptr<!rec_B>
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
// CIR: %[[TRUE:.*]] = cir.const #true
@@ -106,7 +106,7 @@ A *deact_if(bool cond) {
// CIR-LABEL: cir.func {{.*}} @_Z8deact_ifb
// CIR: cir.if {{.*}} {
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
// CIR: %[[TRUE:.*]] = cir.const #true
@@ -162,7 +162,7 @@ A *deact_if(bool cond) {
A *deact_ternary(bool cond) { return (new A(makeB()), cond) ? nullptr : nullptr; }
// CIR-LABEL: cir.func {{.*}} @_Z13deact_ternaryb
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
// CIR: %[[TRUE:.*]] = cir.const #true
@@ -218,7 +218,7 @@ A *deact_while_cond(int n) {
}
// CIR-LABEL: cir.func {{.*}} @_Z16deact_while_condi
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.while {
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
@@ -297,7 +297,7 @@ A *deact_switch(int kind) {
}
// CIR-LABEL: cir.func {{.*}} @_Z12deact_switchi
-// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[ACTIVE:.*]] = cir.alloca "cleanup.isactive" {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.switch({{.*}}) {
// CIR: cir.case(equal, [#cir.int<1> : !s32i]) {
// CIR: %[[PTR:.*]] = cir.call @_Znwm({{.*}}) {{{.*}}builtin}
diff --git a/clang/test/CIR/CodeGen/new-delete.cpp b/clang/test/CIR/CodeGen/new-delete.cpp
index ffc8741fff528..fb60110925c71 100644
--- a/clang/test/CIR/CodeGen/new-delete.cpp
+++ b/clang/test/CIR/CodeGen/new-delete.cpp
@@ -13,8 +13,8 @@ A *a() {
}
// CIR: cir.func {{.*}} @_Z1av() -> !cir.ptr<!rec_A>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR: %[[PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
@@ -88,8 +88,8 @@ A *b() {
}
// CIR: cir.func {{.*}} @_Z1bv() -> !cir.ptr<!rec_A>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR: %[[PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]]) {{{.*}}builtin}
// CIR: cir.cleanup.scope {
@@ -178,8 +178,8 @@ B *c() {
}
// CIR: cir.func {{.*}} @_Z1cv() -> !cir.ptr<!rec_B>{{.*}} {
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_B>>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[PTR:.*]] = cir.call @_ZN1BnwEm(%[[ALLOC_SIZE]]) : (!u64i) -> !cir.ptr<!void>
// CIR: cir.cleanup.scope {
@@ -257,13 +257,13 @@ C *test_new_delete_conditional(bool cond) {
}
// CIR-LABEL: @_Z27test_new_delete_conditionalb
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]]
// CIR: %[[TERN_RESULT:.*]] = cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[NEW_PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]])
// CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]]
@@ -336,12 +336,12 @@ C *test_new_delete_conditional_with_placement(bool cond, int tag) {
}
// CIR-LABEL: @_Z42test_new_delete_conditional_with_placementbi
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[TERN_RESULT:.*]] = cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[TAG_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[TAG_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[TAG_VAL:.*]] = cir.load{{.*}}
// CIR: %[[NEW_PTR:.*]] = cir.call @_Znwmi(%[[ONE]], %[[TAG_VAL]])
@@ -423,13 +423,13 @@ D *test_new_delete_conditional_with_size(bool cond) {
}
// CIR-LABEL: @_Z37test_new_delete_conditional_with_sizeb
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]]
// CIR: cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[ALLOC_SIZE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[NEW_PTR:.*]] = cir.call @_Znwm(%[[ALLOC_SIZE]])
// CIR: cir.store {{.*}}%[[NEW_PTR]], %[[PTR_SAVE]]
@@ -498,13 +498,13 @@ D *test_new_delete_conditional_array(bool cond, int n) {
}
// CIR-LABEL: @_Z33test_new_delete_conditional_arraybi
-// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[CLEANUP_COND:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[CLEANUP_COND]]
// CIR: cir.ternary
-// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
+// CIR: %[[PTR_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[SIZE_SAVE:.*]] = cir.alloca "cond-cleanup.save" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[NEW_RESULT:.*]] = cir.alloca "__new_result" {{.*}} : !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[N:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_EXT:.*]] = cir.cast integral %[[N]] : !s32i -> !s64i
// CIR: %result, %overflow = cir.add.overflow %{{.*}}, %{{.*}} : !u64i -> !u64i
diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp
index f4dabcd970371..b198fb1e3d0d0 100644
--- a/clang/test/CIR/CodeGen/new.cpp
+++ b/clang/test/CIR/CodeGen/new.cpp
@@ -20,9 +20,9 @@ void test_basic_new() {
}
// CHECK: cir.func{{.*}} @_Z14test_basic_newv
-// CHECK: %[[PS_ADDR:.*]] = cir.alloca "ps" {{.*}} init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
-// CHECK: %[[PN_ADDR:.*]] = cir.alloca "pn" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %[[PD_ADDR:.*]] = cir.alloca "pd" {{.*}} init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
+// CHECK: %[[PS_ADDR:.*]] = cir.alloca "ps" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
+// CHECK: %[[PN_ADDR:.*]] = cir.alloca "pn" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[PD_ADDR:.*]] = cir.alloca "pd" {{.*}} init : !cir.ptr<!cir.ptr<!cir.double>>
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8>
// CHECK: %[[NEW_S:.*]] = cir.call @_Znwm(%[[EIGHT]])
// CHECK: %[[NEW_S_PTR:.*]] = cir.cast bitcast %[[NEW_S]]
@@ -67,8 +67,8 @@ void test_new_with_init() {
}
// CHECK: cir.func{{.*}} @_Z18test_new_with_initv
-// CHECK: %[[PN_ADDR:.*]] = cir.alloca "pn" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CHECK: %[[PD_ADDR:.*]] = cir.alloca "pd" {{.*}} init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
+// CHECK: %[[PN_ADDR:.*]] = cir.alloca "pn" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %[[PD_ADDR:.*]] = cir.alloca "pd" {{.*}} init : !cir.ptr<!cir.ptr<!cir.double>>
// CHECK: %[[FOUR:.*]] = cir.const #cir.int<4>
// CHECK: %[[NEW_INT:.*]] = cir.call @_Znwm(%[[FOUR]])
// CHECK: %[[NEW_INT_PTR:.*]] = cir.cast bitcast %[[NEW_INT]]
@@ -118,8 +118,8 @@ void test_new_with_ctor() {
}
// CHECK: cir.func{{.*}} @_Z18test_new_with_ctorv
-// CHECK: %[[PS2_ADDR:.*]] = cir.alloca "ps2" {{.*}} init !cir.ptr<!rec_S2> -> !cir.ptr<!cir.ptr<!rec_S2>>
-// CHECK: %[[PS2_2_ADDR:.*]] = cir.alloca "ps2_2" {{.*}} init !cir.ptr<!rec_S2> -> !cir.ptr<!cir.ptr<!rec_S2>>
+// CHECK: %[[PS2_ADDR:.*]] = cir.alloca "ps2" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S2>>
+// CHECK: %[[PS2_2_ADDR:.*]] = cir.alloca "ps2_2" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S2>>
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8>
// CHECK: %[[NEW_S2:.*]] = cir.call @_Znwm(%[[EIGHT]])
// CHECK: %[[NEW_S2_PTR:.*]] = cir.cast bitcast %[[NEW_S2]]
@@ -161,7 +161,7 @@ void test_new_with_complex_type() {
}
// CHECK: cir.func{{.*}} @_Z26test_new_with_complex_typev
-// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!cir.ptr<!cir.complex<!cir.float>>>
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!cir.complex<!cir.float>>>
// CHECK: %[[COMPLEX_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK: %[[NEW_COMPLEX:.*]] = cir.call @_Znwm(%[[COMPLEX_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CHECK: %[[COMPLEX_PTR:.*]] = cir.cast bitcast %[[NEW_COMPLEX]] : !cir.ptr<!void> -> !cir.ptr<!cir.complex<!cir.float>>
@@ -189,7 +189,7 @@ void t_new_constant_size() {
}
// CHECK: cir.func{{.*}} @_Z19t_new_constant_sizev()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!cir.double>>
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<128> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CHECK: %[[TYPED_PTR:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!cir.double>
@@ -217,7 +217,7 @@ void t_constant_size_nontrivial() {
}
// CHECK: cir.func{{.*}} @_Z26t_constant_size_nontrivialv()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!rec_C>>
// CHECK: %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<11> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
@@ -257,7 +257,7 @@ void t_constant_size_nontrivial2() {
}
// CHECK: cir.func{{.*}} @_Z27t_constant_size_nontrivial2v()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!rec_D>>
// CHECK: %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
@@ -289,7 +289,7 @@ void t_align16_nontrivial() {
}
// CHECK: cir.func{{.*}} @_Z20t_align16_nontrivialv()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!rec_E> -> !cir.ptr<!cir.ptr<!rec_E>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!rec_E>>
// CHECK: %[[NUM_ELEMENTS:.*]] = cir.const #cir.int<2> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<48> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
@@ -328,7 +328,7 @@ void t_new_multidim_constant_size() {
}
// CHECK: cir.func{{.*}} @_Z28t_new_multidim_constant_sizev()
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>>
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<192> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CHECK: %[[TYPED_PTR:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!cir.array<!cir.double x 4> x 3>>
@@ -734,7 +734,7 @@ void test_array_new_with_ctor_init() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z29test_array_new_with_ctor_initv
-// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_F> -> !cir.ptr<!cir.ptr<!rec_F>>
+// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!rec_F>>
// CIR-BEFORE-LPP: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
// CIR-BEFORE-LPP: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[THREE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CIR-BEFORE-LPP: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_F>
@@ -747,7 +747,7 @@ void test_array_new_with_ctor_init() {
// CIR-BEFORE-LPP: cir.return
// CHECK: cir.func {{.*}} @_Z29test_array_new_with_ctor_initv
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_F> -> !cir.ptr<!cir.ptr<!rec_F>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!rec_F>>
// CHECK: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[THREE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CHECK: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_F>
@@ -755,7 +755,7 @@ void test_array_new_with_ctor_init() {
// CHECK: %[[THREE_2:.*]] = cir.const #cir.int<3> : !u64i
// CHECK: %[[ARRAY_BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY_PTR]] : !cir.ptr<!cir.array<!rec_F x 3>> -> !cir.ptr<!rec_F>
// CHECK: %[[ARRAY_END:.*]] = cir.ptr_stride %[[ARRAY_BEGIN]], %[[THREE_2]] : (!cir.ptr<!rec_F>, !u64i) -> !cir.ptr<!rec_F>
-// CHECK: %[[IDX_ADDR:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_F> -> !cir.ptr<!cir.ptr<!rec_F>>
+// CHECK: %[[IDX_ADDR:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_F>>
// CHECK: cir.store %[[ARRAY_BEGIN]], %[[IDX_ADDR]] : !cir.ptr<!rec_F>, !cir.ptr<!cir.ptr<!rec_F>>
// CHECK: cir.do {
// CHECK: %[[CUR:.*]] = cir.load %[[IDX_ADDR]] : !cir.ptr<!cir.ptr<!rec_F>>, !cir.ptr<!rec_F>
@@ -1108,7 +1108,7 @@ void test_array_new_with_ctor_partial_init_list() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z42test_array_new_with_ctor_partial_init_listv
-// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
+// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!rec_G>>
// CIR-BEFORE-LPP: %[[EIGHT:.*]] = cir.const #cir.int<8> : !u64i
// CIR-BEFORE-LPP: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[EIGHT]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CIR-BEFORE-LPP: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_G>
@@ -1129,7 +1129,7 @@ void test_array_new_with_ctor_partial_init_list() {
// CIR-BEFORE-LPP: cir.return
// CHECK: cir.func {{.*}} @_Z42test_array_new_with_ctor_partial_init_listv
-// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
+// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!rec_G>>
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[EIGHT]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef})
// CHECK: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_G>
@@ -1145,7 +1145,7 @@ void test_array_new_with_ctor_partial_init_list() {
// CHECK: %[[SIX:.*]] = cir.const #cir.int<6> : !u64i
// CHECK: %[[ARRAY_BEGIN:.*]] = cir.cast array_to_ptrdecay %[[TAIL_ARRAY]] : !cir.ptr<!cir.array<!rec_G x 6>> -> !cir.ptr<!rec_G>
// CHECK: %[[ARRAY_END:.*]] = cir.ptr_stride %[[ARRAY_BEGIN]], %[[SIX]] : (!cir.ptr<!rec_G>, !u64i) -> !cir.ptr<!rec_G>
-// CHECK: %[[IDX_ADDR:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_G> -> !cir.ptr<!cir.ptr<!rec_G>>
+// CHECK: %[[IDX_ADDR:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_G>>
// CHECK: cir.store %[[ARRAY_BEGIN]], %[[IDX_ADDR]] : !cir.ptr<!rec_G>, !cir.ptr<!cir.ptr<!rec_G>>
// CHECK: cir.do {
// CHECK: %[[CUR:.*]] = cir.load %[[IDX_ADDR]] : !cir.ptr<!cir.ptr<!rec_G>>, !cir.ptr<!rec_G>
diff --git a/clang/test/CIR/CodeGen/no-odr-use.cpp b/clang/test/CIR/CodeGen/no-odr-use.cpp
index 23793dcca0433..f032d7c2c7a3b 100644
--- a/clang/test/CIR/CodeGen/no-odr-use.cpp
+++ b/clang/test/CIR/CodeGen/no-odr-use.cpp
@@ -88,7 +88,7 @@ int f(int i) {
// With CIR, f1() is emitted after the lambda.
// CIR-LABEL: cir.func {{.*}} @_Z1fi(
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init const !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init const : !cir.ptr<!rec_A>
// CIR: %[[A_INIT:.*]] = cir.get_global @[[F_A]] : !cir.ptr<!rec_A>
// CIR: cir.copy %[[A_INIT]] to %[[A_ADDR]]
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
diff --git a/clang/test/CIR/CodeGen/noexcept.cpp b/clang/test/CIR/CodeGen/noexcept.cpp
index 180e1bc350858..e8c1e8f4311c5 100644
--- a/clang/test/CIR/CodeGen/noexcept.cpp
+++ b/clang/test/CIR/CodeGen/noexcept.cpp
@@ -15,9 +15,9 @@ void no_except() {
bool c = noexcept(function_no_except());
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.store {{.*}} %[[CONST_TRUE]], %[[A_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
// CIR: %[[CONST_FALSE:.*]] = cir.const #false
diff --git a/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp b/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp
index bb2613e1c3667..06ce1a8c41d1b 100644
--- a/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp
+++ b/clang/test/CIR/CodeGen/non-scalar-lval-return.cpp
@@ -16,8 +16,8 @@ extern "C" void use() {
int g = getStruct(0).member;
// CIR-LABEL: @use()
- // CIR: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca {{.*}} !rec_Struct -> !cir.ptr<!rec_Struct>
+ // CIR: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_Struct>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[GET_STRUCT_CALL:.*]] = cir.call @getStruct(%[[ZERO]])
// CIR: cir.store{{.*}} %[[GET_STRUCT_CALL]], %[[TEMP_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/non-type-template-param.cpp b/clang/test/CIR/CodeGen/non-type-template-param.cpp
index 0510c795f6da6..39d2e7843025b 100644
--- a/clang/test/CIR/CodeGen/non-type-template-param.cpp
+++ b/clang/test/CIR/CodeGen/non-type-template-param.cpp
@@ -10,7 +10,7 @@ void template_foo() {
int a = N + 5;
}
-// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<5> : !s32i
// CIR: %[[ADD:.*]] = cir.add nsw %[[CONST_1]], %[[CONST_2]] : !s32i
diff --git a/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp b/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp
index 586bf0a7d3909..e945f5147bcf3 100644
--- a/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp
+++ b/clang/test/CIR/CodeGen/nonzeroinit-struct.cpp
@@ -62,10 +62,10 @@ Trivial t_init{1,2.2, &Other::x};
extern "C" void local() {
// CIR-LABEL: @local(
// LLVM-LABEL: @local(
- // CIR: cir.alloca "localMpt" align(8) !rec_WithMemPtr -> !cir.ptr<!rec_WithMemPtr>
- // CIR: cir.alloca "localT" align(8) !rec_Trivial -> !cir.ptr<!rec_Trivial>
- // CIR: %[[MPT_INIT:.*]] = cir.alloca "localMpt_init" align(8) init !rec_WithMemPtr -> !cir.ptr<!rec_WithMemPtr>
- // CIR: %[[T_INIT:.*]] = cir.alloca "localT_init" align(8) init !rec_Trivial -> !cir.ptr<!rec_Trivial>
+ // CIR: cir.alloca "localMpt" align(8) : !cir.ptr<!rec_WithMemPtr>
+ // CIR: cir.alloca "localT" align(8) : !cir.ptr<!rec_Trivial>
+ // CIR: %[[MPT_INIT:.*]] = cir.alloca "localMpt_init" align(8) init : !cir.ptr<!rec_WithMemPtr>
+ // CIR: %[[T_INIT:.*]] = cir.alloca "localT_init" align(8) init : !cir.ptr<!rec_Trivial>
// LLVM: alloca %struct.WithMemPtr
// LLVM: alloca %struct.Trivial
diff --git a/clang/test/CIR/CodeGen/nrvo.cpp b/clang/test/CIR/CodeGen/nrvo.cpp
index 1ad1aa811618d..440761fac4fb7 100644
--- a/clang/test/CIR/CodeGen/nrvo.cpp
+++ b/clang/test/CIR/CodeGen/nrvo.cpp
@@ -23,14 +23,14 @@ struct S f1() {
}
// CIR: cir.func{{.*}} @_Z2f1v() -> !rec_S
-// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} init : !cir.ptr<!rec_S>
// CIR-NEXT: cir.call @_ZN1SC1Ev(%[[RETVAL]]) : (!cir.ptr<!rec_S> {{.*}}) -> ()
// CIR-NEXT: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!rec_S>, !rec_S
// CIR-NEXT: cir.return %[[RET]]
// CIR-NOELIDE: cir.func{{.*}} @_Z2f1v() -> !rec_S
-// CIR-NOELIDE-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_S -> !cir.ptr<!rec_S>
-// CIR-NOELIDE-NEXT: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR-NOELIDE-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_S>
+// CIR-NOELIDE-NEXT: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// CIR-NOELIDE-NEXT: cir.call @_ZN1SC1Ev(%[[S]]) : (!cir.ptr<!rec_S> {{.*}}) -> ()
// CIR-NOELIDE-NEXT: cir.copy %[[S]] to %[[RETVAL]] : !cir.ptr<!rec_S>
// CIR-NOELIDE-NEXT: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!rec_S>, !rec_S
@@ -65,8 +65,8 @@ NonTrivial test_nrvo() {
// TODO(cir): Handle normal cleanup properly.
// CIR: cir.func {{.*}} @_Z9test_nrvov()
-// CIR: %[[RESULT:.*]] = cir.alloca "__retval" {{.*}} !rec_NonTrivial -> !cir.ptr<!rec_NonTrivial>
-// CIR: %[[NRVO_FLAG:.*]] = cir.alloca "nrvo" {{.*}} !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[RESULT:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_NonTrivial>
+// CIR: %[[NRVO_FLAG:.*]] = cir.alloca "nrvo" {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store{{.*}} %[[FALSE]], %[[NRVO_FLAG]]
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/nullptr-init.cpp b/clang/test/CIR/CodeGen/nullptr-init.cpp
index cd764ec5e3ea9..5e9e55c613a21 100644
--- a/clang/test/CIR/CodeGen/nullptr-init.cpp
+++ b/clang/test/CIR/CodeGen/nullptr-init.cpp
@@ -12,9 +12,9 @@ void t1() {
}
// CIR: cir.func{{.*}} @_Z2t1v()
-// CIR-NEXT: %[[P1:.*]] = cir.alloca "p1" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR-NEXT: %[[P2:.*]] = cir.alloca "p2" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR-NEXT: %[[P3:.*]] = cir.alloca "p3" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR-NEXT: %[[P1:.*]] = cir.alloca "p1" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR-NEXT: %[[P2:.*]] = cir.alloca "p2" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR-NEXT: %[[P3:.*]] = cir.alloca "p3" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[NULLPTR1:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[NULLPTR1]], %[[P1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[NULLPTR2:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/opaque.c b/clang/test/CIR/CodeGen/opaque.c
index 745fed1d77abc..91125c35f9221 100644
--- a/clang/test/CIR/CodeGen/opaque.c
+++ b/clang/test/CIR/CodeGen/opaque.c
@@ -11,9 +11,9 @@ void foo2() {
float _Complex c = a ?: b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// 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
diff --git a/clang/test/CIR/CodeGen/opaque.cpp b/clang/test/CIR/CodeGen/opaque.cpp
index 8a76b15428e0c..bc1ce205c3b87 100644
--- a/clang/test/CIR/CodeGen/opaque.cpp
+++ b/clang/test/CIR/CodeGen/opaque.cpp
@@ -10,8 +10,8 @@ void foo() {
int b = 1 ?: a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
@@ -29,9 +29,9 @@ void foo2() {
float _Complex c = a ?: b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!cir.float>>
// 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
@@ -107,9 +107,9 @@ void foo3() {
int c = a ?: b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s32i>
// 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: %[[RESULT:.*]] = cir.ternary(%[[A_BOOL]], true {
@@ -162,8 +162,8 @@ void test_gnu_binary_lvalue_assign() {
}
// CIR-LABEL: cir.func{{.*}} @_Z29test_gnu_binary_lvalue_assignv(
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[A_VAL:.*]] = cir.load{{.*}} %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[A_BOOL:.*]] = cir.cast int_to_bool %[[A_VAL]] : !s32i -> !cir.bool
// CIR: %[[TERNARY_PTR:.*]] = cir.ternary(%[[A_BOOL]], true {
@@ -210,8 +210,8 @@ void test_gnu_binary_lvalue_compound() {
}
// CIR-LABEL: cir.func{{.*}} @_Z31test_gnu_binary_lvalue_compoundv(
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[A_VAL:.*]] = cir.load{{.*}} %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[A_BOOL:.*]] = cir.cast int_to_bool %[[A_VAL]] : !s32i -> !cir.bool
// CIR: %[[LVAL_PTR:.*]] = cir.ternary(%[[A_BOOL]], true {
@@ -265,10 +265,10 @@ void test_gnu_binary_lvalue_ptr() {
}
// CIR-LABEL: cir.func{{.*}} @_Z26test_gnu_binary_lvalue_ptrv(
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[Q:.*]] = cir.alloca "q" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[Q:.*]] = cir.alloca "q" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[P_VAL:.*]] = cir.load{{.*}} %[[P]]
// CIR: %[[P_BOOL:.*]] = cir.cast ptr_to_bool %[[P_VAL]]
// CIR: %[[PTR_RESULT:.*]] = cir.ternary(%[[P_BOOL]], true {
diff --git a/clang/test/CIR/CodeGen/openmp_default_simd_align.c b/clang/test/CIR/CodeGen/openmp_default_simd_align.c
index 18644eb0e4fcd..9600f9ae74c88 100644
--- a/clang/test/CIR/CodeGen/openmp_default_simd_align.c
+++ b/clang/test/CIR/CodeGen/openmp_default_simd_align.c
@@ -14,7 +14,7 @@ int f0(void) {
return __builtin_omp_required_simd_align(struct s0);
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[CONST_16:.*]] = cir.const #cir.int<16> : !s32i
// CIR: cir.store %[[CONST_16]], %[[RET_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_RET:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGen/pack-indexing.cpp b/clang/test/CIR/CodeGen/pack-indexing.cpp
index 6925d029c8d69..47ecc236a89e9 100644
--- a/clang/test/CIR/CodeGen/pack-indexing.cpp
+++ b/clang/test/CIR/CodeGen/pack-indexing.cpp
@@ -7,10 +7,10 @@
auto pack_indexing(auto... p) { return p...[0]; }
-// CIR: %[[P_0:.*]] = cir.alloca "p" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[P_1:.*]] = cir.alloca "p" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[P_2:.*]] = cir.alloca "p" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[P_0:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[P_1:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[P_2:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[RESULT:.*]] = cir.load{{.*}} %[[P_0]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store %[[RESULT]], %[[RET_VAL]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load %[[RET_VAL]] : !cir.ptr<!s32i>, !s32i
@@ -33,7 +33,7 @@ auto pack_indexing(auto... p) { return p...[0]; }
int pack_indexing_scalar() { return pack_indexing(1, 2, 3); }
-// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[RESULT:.*]] = cir.call @_Z13pack_indexingIJiiiEEDaDpT_({{.*}}, {{.*}}, {{.*}}) : (!s32i {llvm.noundef}, !s32i {llvm.noundef}, !s32i {llvm.noundef}) -> (!s32i {llvm.noundef})
// CIR: cir.store %[[RESULT]], %[[RET_VAL]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP:.*]] = cir.load %[[RET_VAL]] : !cir.ptr<!s32i>, !s32i
@@ -54,9 +54,9 @@ float _Complex pack_indexing_complex() {
}
// CIR: cir.func {{.*}} @_Z21pack_indexing_complexv()
-// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[COMPLEX_0:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
-// CIR: %[[COMPLEX_1:.*]] = cir.alloca "coerce" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[COMPLEX_0:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[COMPLEX_1:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[CONST_COMPLEX_0:.*]] = cir.const #cir.const_complex<#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: %[[CONST_COMPLEX_1:.*]] = cir.const #cir.const_complex<#cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float> : !cir.complex<!cir.float>
// CIR: cir.store {{.*}} %[[CONST_COMPLEX_0]], %[[COMPLEX_0]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
diff --git a/clang/test/CIR/CodeGen/paren-init-list-eh.cpp b/clang/test/CIR/CodeGen/paren-init-list-eh.cpp
index 5b123f62a7c3e..7b02226551135 100644
--- a/clang/test/CIR/CodeGen/paren-init-list-eh.cpp
+++ b/clang/test/CIR/CodeGen/paren-init-list-eh.cpp
@@ -22,7 +22,7 @@ void test_init_list_with_dtor() {
}
// CIR: cir.func {{.*}} @_Z24test_init_list_with_dtorv
-// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} init !rec_Outer -> !cir.ptr<!rec_Outer>
+// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} init : !cir.ptr<!rec_Outer>
// CIR: %[[S1:.*]] = cir.get_member %[[O]][0] {name = "s1"} : !cir.ptr<!rec_Outer> -> !cir.ptr<!rec_Struk>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR: cir.call @_ZN5StrukC1Ei(%[[S1]], %[[ONE]])
diff --git a/clang/test/CIR/CodeGen/paren-init-list.cpp b/clang/test/CIR/CodeGen/paren-init-list.cpp
index 755978a120d52..abe6cafb000da 100644
--- a/clang/test/CIR/CodeGen/paren-init-list.cpp
+++ b/clang/test/CIR/CodeGen/paren-init-list.cpp
@@ -15,7 +15,7 @@ void cxx_paren_list_init_expr() { CompleteS a(1, 'a'); }
// CIR-DAG: cir.global "private" constant cir_private @[[PAREN_A:.*]] = #cir.const_record<{#cir.int<1> : !s32i, #cir.int<97> : !s8i}> : !rec_CompleteS
// LLVM-DAG: @[[PAREN_A:.*]] = private constant %struct.CompleteS { i32 1, i8 97 }
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: %[[CONST:.*]] = cir.get_global @[[PAREN_A]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]]
@@ -40,7 +40,7 @@ void test_init_list_with_dtor() {
}
// CIR: cir.func {{.*}} @_Z24test_init_list_with_dtorv
-// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} init !rec_Outer -> !cir.ptr<!rec_Outer>
+// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} init : !cir.ptr<!rec_Outer>
// CIR: %[[H:.*]] = cir.get_member %[[O]][0] {name = "h"} : !cir.ptr<!rec_Outer> -> !cir.ptr<!rec_HasDtor>
// CIR: %[[VAL:.*]] = cir.get_member %[[H]][0] {name = "val"} : !cir.ptr<!rec_HasDtor> -> !cir.ptr<!s32i>
// CIR: %[[CONST:.*]] = cir.const #cir.int<1>
diff --git a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
index 1924a515d3b19..01e045f376a4f 100644
--- a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
+++ b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
@@ -158,7 +158,7 @@ constexpr int arr5[2](2);
// LLVM-NEXT: [[TMP_0:%.*]] = load {{.*}}, ptr [[RETVAL]], align 8
// LLVM-NEXT: ret {{.*}}[[TMP_0]]
// CIR-LABEL: cir.func {{.*}}@_Z4foo1v()
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_A1:.*]] = cir.get_global @_ZL2a1 : !cir.ptr<![[STRUCT_A]]>
// CIR: cir.copy %[[GET_A1]] to %[[A_ALLOCA]] : !cir.ptr<![[STRUCT_A]]>
A foo1() {
@@ -168,7 +168,7 @@ A foo1() {
// LLVM: define dso_local {{.*}}@{{.*foo2.*}}
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}, ptr {{.*}}[[B1]], i64 24, i1 false)
// CIR: cir.func {{.*}}@_Z4foo2v()
-// CIR: %[[B_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_B]] -> !cir.ptr<![[STRUCT_B]]>
+// CIR: %[[B_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[STRUCT_B]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2b1 : !cir.ptr<![[STRUCT_B]]>
// CIR: cir.copy %[[GET_GLOB]] to %[[B_ALLOCA]] : !cir.ptr<![[STRUCT_B]]>
B foo2() {
@@ -178,7 +178,7 @@ B foo2() {
// LLVM: define dso_local {{.*}}@{{.*foo3.*}}
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}, ptr {{.*}}[[C1]], i64 48, i1 false)
// CIR: cir.func {{.*}}@_Z4foo3v()
-// CIR: %[[C_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_C]] -> !cir.ptr<![[STRUCT_C]]>
+// CIR: %[[C_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[STRUCT_C]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2c1
// CIR: %[[GLOB_CAST:.*]] = cir.cast bitcast %[[GET_GLOB]] : !cir.ptr<!{{.*}}> -> !cir.ptr<![[STRUCT_C]]>
// CIR: cir.copy %[[GLOB_CAST]] to %[[C_ALLOCA]] : !cir.ptr<![[STRUCT_C]]>
@@ -208,9 +208,9 @@ C foo3() {
// LLVM-NEXT: store i32 2, ptr [[C]]
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_Z4foo4v()
-// CIR: %[[C2_ALLOCA:.*]] = cir.alloca "c2" {{.*}} init ![[STRUCT_C]] -> !cir.ptr<![[STRUCT_C]]>
-// CIR: %[[B_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} ![[STRUCT_B]] -> !cir.ptr<![[STRUCT_B]]>
-// CIR: %[[A_TMP:.*]] = cir.alloca "ref.tmp1" {{.*}} ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
+// CIR: %[[C2_ALLOCA:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<![[STRUCT_C]]>
+// CIR: %[[B_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<![[STRUCT_B]]>
+// CIR: %[[A_TMP:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<![[STRUCT_A]]>
// CIR: %[[C_BASE:.*]] = cir.base_class_addr %[[C2_ALLOCA]] : !cir.ptr<![[STRUCT_C]]> nonnull [0] -> !cir.ptr<![[STRUCT_B]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[B_TMP]][0] {name = "a"} : !cir.ptr<![[STRUCT_B]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[GET_A]][0] {name = "i"} : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!s8i>
@@ -243,7 +243,7 @@ void foo4() {
// LLVM: [[RETVAL:%.*]] = alloca [[UNION_U]]
// LLVM-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}[[RETVAL]], ptr {{.*}}[[U1]], i64 16, i1 false)
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo5v()
-// CIR: %[[RET:.*]] = cir.alloca "__retval" align(8) ![[UNION_U]] -> !cir.ptr<![[UNION_U]]>
+// CIR: %[[RET:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[UNION_U]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2u1 : !cir.ptr<!{{.*}}>
// CIR: %[[GLOB_TO_U:.*]] = cir.cast bitcast %[[GET_GLOB]] : !cir.ptr<!{{.*}}> -> !cir.ptr<![[UNION_U]]>
// CIR: cir.copy %[[GLOB_TO_U]] to %[[RET]] : !cir.ptr<![[UNION_U]]>
@@ -257,8 +257,8 @@ U foo5() {
// LLVM-DAG: [[A:%.*]] = alloca [[STRUCT_A]]
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}[[RETVAL]], ptr {{.*}}[[A]], i64 16, i1 false)
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo61A(
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(8) init ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[UNION_U]] -> !cir.ptr<![[UNION_U]]>
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(8) init : !cir.ptr<![[STRUCT_A]]>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[UNION_U]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[RET_ALLOCA:.*]][1] {name = "a"} : !cir.ptr<![[UNION_U]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: cir.copy %[[A_ALLOCA]] to %[[GET_A:.*]] : !cir.ptr<![[STRUCT_A]]>
U foo6(A a) {
@@ -284,7 +284,7 @@ U foo6(A a) {
// LLVM-NEXT: store double 1.110000e+02, ptr [[J4]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL; cir.func no_inline dso_local @_Z4foo7v()
-// CIR: %[[D_ALLOCA:.*]] = cir.alloca "d" align(8) init ![[STRUCT_D]] -> !cir.ptr<![[STRUCT_D]]>
+// CIR: %[[D_ALLOCA:.*]] = cir.alloca "d" align(8) init : !cir.ptr<![[STRUCT_D]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[D_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_D]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[GET_A]][0] {name = "i"} : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!s8i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s8i
@@ -316,7 +316,7 @@ void foo7() {
// LLVM: dso_local {{.*}}@{{.*foo8.*}}(
// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr {{.*}}, ptr {{.*}}[[D1]], i64 56, i1 false)
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo8v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_D]] -> !cir.ptr<![[STRUCT_D]]>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[STRUCT_D]]>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL2d1 :
// CIR: %[[GLOB_CAST:.*]] = cir.cast bitcast %[[GET_GLOB]] : !cir.ptr<!{{.*}}> -> !cir.ptr<![[STRUCT_D]]>
// CIR: cir.copy %[[GLOB_CAST]] to %[[RET_ALLOCA]] : !cir.ptr<![[STRUCT_D]]>
@@ -338,7 +338,7 @@ D foo8() {
// LLVM-NEXT: store double 2.000000e+00, ptr [[J2]], align 8
// LLVM-NEXT: [[C:%.*]] = getelementptr {{.*}}[[STRUCT_D]], ptr [[D]], i32 0, i32 3
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo9v()
-// CIR: %[[D_ALLOCA:.*]] = cir.alloca "d" align(8) init ![[STRUCT_D]] -> !cir.ptr<![[STRUCT_D]]>
+// CIR: %[[D_ALLOCA:.*]] = cir.alloca "d" align(8) init : !cir.ptr<![[STRUCT_D]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[D_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_D]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[GET_A]][0] {name = "i"} : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!s8i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s8i
@@ -364,7 +364,7 @@ void foo9() {
// LLVM: define dso_local noundef ptr @{{.*foo10.*}}()
// FIXME: CIR lowering has an extra load here.
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo10v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL4arr1 : !cir.ptr<!cir.array<!s32i x 3>>
// CIR: %[[GLOB_DECAY:.*]] = cir.cast array_to_ptrdecay %[[GET_GLOB]] : !cir.ptr<!cir.array<!s32i x 3>> -> !cir.ptr<!s32i>
// CIR: cir.store %[[GLOB_DECAY]], %[[RET_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -390,10 +390,10 @@ const int* foo10() {
// LLVM-NEXT: br i1 [[ARRINIT_DONE]], label
// LLVM: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo11ii
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ALLOCA:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ARR2_ALLOCA:.*]] = cir.alloca "arr2" align(16) init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
-// CIR: %[[ARR_ITR:.*]] = cir.alloca "arrayinit.temp" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+// CIR: %[[B_ALLOCA:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+// CIR: %[[ARR2_ALLOCA:.*]] = cir.alloca "arr2" align(16) init : !cir.ptr<!cir.array<!s32i x 4>>
+// CIR: %[[ARR_ITR:.*]] = cir.alloca "arrayinit.temp" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[ARR2_DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARR2_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 4>> -> !cir.ptr<!s32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %[[A_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store align(4) %[[A_LOAD]], %[[ARR2_DECAY]] : !s32i, !cir.ptr<!s32i>
@@ -436,9 +436,9 @@ void foo11(int a, int b) {
// LLVM-NEXT: store i32 [[TMP_1]], ptr [[ARRINIT_ELEMENT]], align 4
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo12ii
-// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ALLOCA:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[ARR3_ALLOCA:.*]] = cir.alloca "arr3" align(4) init !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[A_ALLOCA:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+// CIR: %[[B_ALLOCA:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+// CIR: %[[ARR3_ALLOCA:.*]] = cir.alloca "arr3" align(4) init : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARR3_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[A_LOAD:.*]] = cir.load align(4) %[[A_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store align(4) %[[A_LOAD]], %[[ARR_DECAY]] : !s32i, !cir.ptr<!s32i>
@@ -456,7 +456,7 @@ void foo12(int a, int b) {
// LLVM-NEXT: [[TMP_0:%.*]] = load {{.*}}, ptr [[RETVAL]], align 8
// LLVM-NEXT: ret {{.*}}[[TMP_0]]
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo13v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) ![[STRUCT_A]] -> !cir.ptr<![[STRUCT_A]]>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<![[STRUCT_A]]>
// CIR; %[[GET_GLOB:.*]] = cir.get_global @_ZL2a2 : !cir.ptr<![[STRUCT_A]]>
// CIR; cir.copy %[[GET_GLOB]] to %[[RET_ALLOCA]] : !cir.ptr<![[STRUCT_A]]>
A foo13() {
@@ -466,7 +466,7 @@ A foo13() {
// LLVM: define dso_local noundef ptr @{{.*foo14.*}}()
// LLVM: ret ptr
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo14v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL4arr4 : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[GLOB_DECAY]] = cir.cast array_to_ptrdecay %[[GET_GLOB]] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!s32i>
// CIR: cir.store %[[GLOB_DECAY]], %[[RET_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -477,7 +477,7 @@ const int* foo14() {
// LLVM: define dso_local noundef ptr @{{.*foo15.*}}()
// LLVM: ret ptr
// CIR-LABEL: cir.func {{.*}}@_Z5foo15v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZL4arr5 : !cir.ptr<!cir.array<!s32i x 2>>
// CIR: %[[GLOB_DECAY:.*]] = cir.cast array_to_ptrdecay %[[GET_GLOB]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: cir.store %[[GLOB_DECAY]], %[[RET_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -492,8 +492,8 @@ const int* foo15() {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[ARR_6]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo16v()
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) !cir.array<!s32i x 1> -> !cir.ptr<!cir.array<!s32i x 1>>
-// CIR: %[[ARR6_ALLOCA:.*]] = cir.alloca "arr6" align(8) init const !cir.ptr<!cir.array<!s32i x 0>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) : !cir.ptr<!cir.array<!s32i x 1>>
+// CIR: %[[ARR6_ALLOCA:.*]] = cir.alloca "arr6" align(8) init const : !cir.ptr<!cir.ptr<!cir.array<!s32i x 0>>>
// CIR: %[[TEMP_DECAY:.*]] = cir.cast array_to_ptrdecay %[[TEMP_ALLOCA]] : !cir.ptr<!cir.array<!s32i x 1>> -> !cir.ptr<!s32i>
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR: cir.store align(4) %[[THREE]], %[[TEMP_DECAY]] : !s32i, !cir.ptr<!s32i>
@@ -515,9 +515,9 @@ void foo16() {
// LLVM: store ptr [[REF_TMP]], ptr [[ARR_7]], align 8
// LLVM: ret void
// CIR-LABEL: cir.func no_inline dso_local @_Z5foo17v()
-// CIR: %[[ARR_TEMP:.*]] = cir.alloca "ref.tmp0" align(4) !cir.array<!s32i x 2> -> !cir.ptr<!cir.array<!s32i x 2>>
-// CIR: %[[ARR7_ALLOCA:.*]] = cir.alloca "arr7" align(8) init const !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>
-// CIR: %[[ITR:.*]] = cir.alloca "arrayinit.temp" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[ARR_TEMP:.*]] = cir.alloca "ref.tmp0" align(4) : !cir.ptr<!cir.array<!s32i x 2>>
+// CIR: %[[ARR7_ALLOCA:.*]] = cir.alloca "arr7" align(8) init const : !cir.ptr<!cir.ptr<!cir.array<!s32i x 2>>>
+// CIR: %[[ITR:.*]] = cir.alloca "arrayinit.temp" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[TEMP_LOAD:.*]] = cir.cast array_to_ptrdecay %[[ARR_TEMP]] : !cir.ptr<!cir.array<!s32i x 2>> -> !cir.ptr<!s32i>
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store align(4) %[[FOUR]], %[[TEMP_LOAD]] : !s32i, !cir.ptr<!s32i>
@@ -552,7 +552,7 @@ void foo17() {
// LLVM-NEXT: store ptr [[STR]], ptr [[FN]], align 8
// LLVM: ret void
// CIR: cir.func {{.*}}@_Z5foo18v()
-// CIR: %[[E_ALLOCA:.*]] = cir.alloca "e" {{.*}} init ![[STRUCT_E]] -> !cir.ptr<![[STRUCT_E]]>
+// CIR: %[[E_ALLOCA:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<![[STRUCT_E]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[E_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_E]]> -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[ONE]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -571,7 +571,7 @@ void foo18() {
// LLVM-NEXT: call void @{{.*F.*}}(ptr noundef nonnull align 1 dereferenceable(1) [[F]], i32 noundef 1)
// LLVM: ret void
// CIR: cir.func no_inline dso_local @_Z5foo19v() attributes {{{.*}}nothrow} {
-// CIR: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init ![[STRUCT_G]] -> !cir.ptr<![[STRUCT_G]]>
+// CIR: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init : !cir.ptr<![[STRUCT_G]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[G_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_G]]> -> !cir.ptr<!s32i>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
// CIR: cir.store{{.*}} %[[TWO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -600,8 +600,8 @@ namespace gh61145 {
// LLVM: call void @_ZN7gh611453VecD1Ev(ptr {{.*}}[[V]])
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh611455make1ILi0EEEvv()
- // CIR: %[[V_ALLOCA:.*]] = cir.alloca "v" align(1) init ![[STRUCT_VEC]] -> !cir.ptr<![[STRUCT_VEC]]>
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_S1]] -> !cir.ptr<![[STRUCT_S1]]>
+ // CIR: %[[V_ALLOCA:.*]] = cir.alloca "v" align(1) init : !cir.ptr<![[STRUCT_VEC]]>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<![[STRUCT_S1]]>
// CIR: cir.call @_ZN7gh611453VecC1Ev(%[[V_ALLOCA]])
// CIR: %[[S1_TO_VEC:.*]] = cir.cast bitcast %[[TMP_ALLOCA]] : !cir.ptr<![[STRUCT_S1]]> -> !cir.ptr<![[STRUCT_VEC]]>
// CIR: cir.call @_ZN7gh611453VecC1EOS0_(%[[S1_TO_VEC]], %[[V_ALLOCA]])
@@ -629,8 +629,8 @@ namespace gh61145 {
// LLVM: call void @_ZN7gh611453VecD1Ev(ptr {{.*}}[[V]])
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh611455make2ILi0EEEvv()
- // CIR: %[[V_ALLOCA:.*]] = cir.alloca "v" align(1) init ![[STRUCT_VEC]] -> !cir.ptr<![[STRUCT_VEC]]>
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_S2]] -> !cir.ptr<![[STRUCT_S2]]>
+ // CIR: %[[V_ALLOCA:.*]] = cir.alloca "v" align(1) init : !cir.ptr<![[STRUCT_VEC]]>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<![[STRUCT_S2]]>
// CIR: cir.call @_ZN7gh611453VecC1Ev(%[[V_ALLOCA]])
// CIR: %[[S2_TO_VEC:.*]] = cir.cast bitcast %[[TMP_ALLOCA]] : !cir.ptr<![[STRUCT_S2]]> -> !cir.ptr<![[STRUCT_VEC]]>
// CIR: cir.call @_ZN7gh611453VecC1EOS0_(%[[S2_TO_VEC]], %[[V_ALLOCA]])
@@ -658,7 +658,7 @@ namespace gh62266 {
// LLVM-NEXT: store i32 2, ptr [[J]], align 4
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh622665foo20Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "h" {{.*}} init ![[STRUCT_H]] -> !cir.ptr<![[STRUCT_H]]>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "h" {{.*}} init : !cir.ptr<![[STRUCT_H]]>
// CIR: %[[GET_I:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "i"} : !cir.ptr<![[STRUCT_H]]> -> !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -684,8 +684,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[R]], align 8
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh615675foo21Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
- // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -708,8 +708,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[R]], align 8
// LLVM: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh615675foo22Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
- // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -730,8 +730,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[I_ADDR]], ptr [[R]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func no_inline dso_local @_ZN7gh615675foo23Ei(%arg0: !s32i {llvm.noundef}
- // CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<![[STRUCT_I]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -751,8 +751,8 @@ namespace gh61567 {
// LLVM-NEXT: store ptr [[REF_TMP]], ptr [[R]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.func {{.*}}@_ZN7gh615675foo24Ev()
- // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} ![[STRUCT_I]] -> !cir.ptr<![[STRUCT_I]]>
- // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[TMP_ALLOCA:.*]] = cir.alloca "agg.tmp.ensured" {{.*}} : !cir.ptr<![[STRUCT_I]]>
+ // CIR: %[[INT_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[GET_A:.*]] = cir.get_member %[[TMP_ALLOCA:.*]][0] {name = "a"} : !cir.ptr<![[STRUCT_I]]> -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]] : !s32i, !cir.ptr<!s32i>
@@ -776,7 +776,7 @@ namespace gh68198 {
// LLVM-NEXT: store ptr [[CALL_PTR]], ptr [[ARR_8]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.{{.*}}@_ZN7gh681985foo25Ev()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr8" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr8" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_TO_ARR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
@@ -806,7 +806,7 @@ namespace gh68198 {
// LLVM-NEXT: store ptr [[CALL_PTR]], ptr [[ARR_10]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.{{.*}}@_ZN7gh681985foo26Ev()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr9" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr9" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_TO_ARR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!s32i x 2>>
@@ -849,7 +849,7 @@ namespace gh68198 {
// LLVM-NEXT: store ptr [[CALL_PTR]], ptr [[ARR_10]], align 8
// LLVM-NEXT: ret void
// CIR-LABEL: cir.{{.*}}@_ZN7gh681985foo27Ev()
- // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr10" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARR_ALLOCA:.*]] = cir.alloca "arr10" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<32> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_TO_ARR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!cir.array<!s32i x 2>>
diff --git a/clang/test/CIR/CodeGen/partial-array-cleanup.cpp b/clang/test/CIR/CodeGen/partial-array-cleanup.cpp
index 4dc6e6739dd4d..4bfb65ee4d651 100644
--- a/clang/test/CIR/CodeGen/partial-array-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/partial-array-cleanup.cpp
@@ -16,7 +16,7 @@ void test_partial_array_cleanup() {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z26test_partial_array_cleanupv()
-// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
+// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.array<!rec_S x 4>>
// CIR-BEFORE-LPP: cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> {
// CIR-BEFORE-LPP: ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -26,11 +26,11 @@ void test_partial_array_cleanup() {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z26test_partial_array_cleanupv()
-// CIR: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
+// CIR: %[[ARRAY:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!cir.array<!rec_S x 4>>
// CIR: %[[CONST4:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[CONST4]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[BEGIN]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.cleanup.scope {
// CIR: cir.do {
@@ -165,12 +165,12 @@ void test_variable_size_partial_array_cleanup(int n) {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z40test_variable_size_partial_array_cleanupi
-// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR-BEFORE-LPP: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP: cir.stacksave
// CIR-BEFORE-LPP: cir.cleanup.scope {
-// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
+// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init size(%[[N]]) : !cir.ptr<!rec_S>
// CIR-BEFORE-LPP: cir.array.ctor %[[VLA]], %[[N]] : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP: ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -190,19 +190,19 @@ void test_variable_size_partial_array_cleanup(int n) {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z40test_variable_size_partial_array_cleanupi
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR: %[[STACK:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK]], %[[SAVED_STACK]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[BEGIN:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[BEGIN:.*]] = cir.alloca "s" {{.*}} init size(%[[N]]) : !cir.ptr<!rec_S>
// CIR: %[[END:.*]] = cir.ptr_stride %[[BEGIN]], %[[N]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CIR: %[[IS_NONZERO:.*]] = cir.cmp ne %[[N]], %[[ZERO]] : !u64i
// CIR: cir.if %[[IS_NONZERO]] {
-// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[BEGIN]], %[[ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.cleanup.scope {
// CIR: cir.do {
@@ -244,7 +244,7 @@ void test_variable_size_partial_array_cleanup(int n) {
// CIR: %[[LAST:.*]] = cir.ptr_stride %[[BEGIN]], %[[N]] : (!cir.ptr<!rec_S>, !u64i) -> !cir.ptr<!rec_S>
// CIR: %[[DTOR_NE:.*]] = cir.cmp ne %[[LAST]], %[[BEGIN]] : !cir.ptr<!rec_S>
// CIR: cir.if %[[DTOR_NE]] {
-// CIR: %[[DTOR_ITER:.*]] = cir.alloca "__array_idx" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[DTOR_ITER:.*]] = cir.alloca "__array_idx" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.store %[[LAST]], %[[DTOR_ITER]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.do {
// CIR: %[[DTOR_CUR:.*]] = cir.load %[[DTOR_ITER]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
@@ -438,8 +438,8 @@ void test_multi_dim_vla(int n, int m) {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z18test_multi_dim_vlaii
-// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BEFORE-LPP: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BEFORE-LPP: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init : !cir.ptr<!s32i>
// CIR-BEFORE-LPP: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP: %[[M_VAL:.*]] = cir.load {{.*}} %[[M_ADDR]] : !cir.ptr<!s32i>, !s32i
@@ -447,7 +447,7 @@ void test_multi_dim_vla(int n, int m) {
// CIR-BEFORE-LPP: cir.stacksave
// CIR-BEFORE-LPP: cir.cleanup.scope {
// CIR-BEFORE-LPP: %[[NM:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
-// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[NM]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
+// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init size(%[[NM]]) : !cir.ptr<!rec_S>
// CIR-BEFORE-LPP: cir.array.ctor %[[VLA]], {{.*}} : !cir.ptr<!rec_S>, !u64i {
// CIR-BEFORE-LPP: ^bb0(%[[CTOR_ARG:.*]]: !cir.ptr<!rec_S>):
// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[CTOR_ARG]]) : (!cir.ptr<!rec_S>{{.*}}) -> ()
@@ -467,16 +467,16 @@ void test_multi_dim_vla(int n, int m) {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z18test_multi_dim_vlaii
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR: %[[M_VAL:.*]] = cir.load {{.*}} %[[M_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[M:.*]] = cir.cast integral %[[M_VAL]] : !s32i -> !u64i
// CIR: cir.cleanup.scope {
// CIR: %[[NM:.*]] = cir.mul nuw %[[N]], %[[M]] : !u64i
-// CIR: %[[BEGIN:.*]] = cir.alloca "s" {{.*}} init %[[NM]] : !u64i, !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[BEGIN:.*]] = cir.alloca "s" {{.*}} init size(%[[NM]]) : !cir.ptr<!rec_S>
// CIR: cir.call @_ZN1SC1Ev
// CIR: } cleanup eh {
// CIR: cir.call @_ZN1SD1Ev
@@ -552,12 +552,12 @@ void test_vla_of_constant_array(int n) {
}
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z26test_vla_of_constant_arrayi
-// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BEFORE-LPP: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR-BEFORE-LPP: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR-BEFORE-LPP: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR-BEFORE-LPP: cir.stacksave
// CIR-BEFORE-LPP: cir.cleanup.scope {
-// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
+// CIR-BEFORE-LPP: %[[VLA:.*]] = cir.alloca "s" {{.*}} init size(%[[N]]) : !cir.ptr<!cir.array<!rec_S x 4>>
// CIR-BEFORE-LPP: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
// CIR-BEFORE-LPP: %[[TOTAL:.*]] = cir.mul nuw %[[N]], %[[FOUR]] : !u64i
// CIR-BEFORE-LPP: %[[ELEM_PTR:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
@@ -583,11 +583,11 @@ void test_vla_of_constant_array(int n) {
// CIR-BEFORE-LPP: }
// CIR: cir.func {{.*}} @_Z26test_vla_of_constant_arrayi
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[N_VAL:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N:.*]] = cir.cast integral %[[N_VAL]] : !s32i -> !u64i
// CIR: cir.cleanup.scope {
-// CIR: %[[VLA:.*]] = cir.alloca "s" {{.*}} init %[[N]] : !u64i, !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
+// CIR: %[[VLA:.*]] = cir.alloca "s" {{.*}} init size(%[[N]]) : !cir.ptr<!cir.array<!rec_S x 4>>
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[TOTAL:.*]] = cir.mul nuw %[[N]], %[[FOUR]] : !u64i
// CIR: %[[ELEM_PTR:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
@@ -664,8 +664,8 @@ void test_init_list_partial_array_cleanup() {
}
// CIR-LABEL: cir.func {{.*}} @_Z36test_init_list_partial_array_cleanupv()
-// CIR: %[[ARRAY:.*]] = cir.alloca "arr" {{.*}} init !cir.array<!rec_S x 4> -> !cir.ptr<!cir.array<!rec_S x 4>>
-// CIR: %[[END_OF_INIT:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[ARRAY:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.array<!rec_S x 4>>
+// CIR: %[[END_OF_INIT:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[BEGIN:.*]] = cir.cast array_to_ptrdecay %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 4>> -> !cir.ptr<!rec_S>
// CIR: cir.store {{.*}} %[[BEGIN]], %[[END_OF_INIT]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/pass-object-size.c b/clang/test/CIR/CodeGen/pass-object-size.c
index df9d26ed863a9..23b95e8f38951 100644
--- a/clang/test/CIR/CodeGen/pass-object-size.c
+++ b/clang/test/CIR/CodeGen/pass-object-size.c
@@ -16,7 +16,7 @@ void test_constant() {
}
// CIR: cir.func {{.*}} @test_constant()
-// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!s32i>
// CIR: %[[CAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: cir.call @b(%[[CAST]], %[[SIZE]]) : (!cir.ptr<!void> {{.*}}, !u64i {{.*}}) -> ()
@@ -42,7 +42,7 @@ void test_vla(int n) {
}
// CIR: cir.func {{.*}} @test_vla
-// CIR: %[[VLA:.*]] = cir.alloca "d" align(16) %{{.*}} : !u64i, !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VLA:.*]] = cir.alloca "d" align(16) size(%{{.*}}) : !cir.ptr<!s32i>
// CIR: %[[CAST1:.*]] = cir.cast bitcast %[[VLA]] : !cir.ptr<!s32i> -> !cir.ptr<!void>
// CIR: %[[SIZE1:.*]] = cir.objsize max nullunknown %[[CAST1]] : !cir.ptr<!void> -> !u64i
// CIR: cir.call @b(%[[CAST1]], %[[SIZE1]]) : (!cir.ptr<!void> {{.*}}, !u64i {{.*}}) -> ()
diff --git a/clang/test/CIR/CodeGen/placement-new.cpp b/clang/test/CIR/CodeGen/placement-new.cpp
index 1ea4aeeb53e3e..53e484abcf38c 100644
--- a/clang/test/CIR/CodeGen/placement-new.cpp
+++ b/clang/test/CIR/CodeGen/placement-new.cpp
@@ -18,7 +18,7 @@ void test_reserved_placement_new(void *p) {
// CIR-LABEL: cir.func {{.*}} @_Z27test_reserved_placement_newPv(
// CIR-SAME: %[[ARG0:.*]]: !cir.ptr<!void>
-// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[P:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: cir.store %[[ARG0]], %[[P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[PTR:.*]] = cir.load{{.*}} %[[P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[PTR_A:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_A>
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 40bbf81c2e56c..ac4cf4e63b954 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
@@ -171,8 +171,8 @@ auto bitcast(int Foo::*x) {
// CIR-BEFORE: %{{.*}} = cir.cast bitcast %[[X]] : !cir.data_member<!s32i in !rec_Foo> -> !cir.data_member<!s32i in !rec_Bar>
// CIR-AFTER: cir.func {{.*}} @_Z7bitcastM3Fooi(%[[ARG0:.*]]: !s64i
-// CIR-AFTER: %[[X_ADDR:.*]] = cir.alloca "x" align(8) init !s64i -> !cir.ptr<!s64i>
-// CIR-AFTER: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[X_ADDR:.*]] = cir.alloca "x" align(8) init : !cir.ptr<!s64i>
+// CIR-AFTER: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!s64i>
// CIR-AFTER: cir.store %[[ARG0]], %[[X_ADDR]]
// CIR-AFTER: %[[X:.*]] = cir.load{{.*}} %[[X_ADDR]]
// CIR-AFTER: cir.store %[[X]], %[[RET_ADDR]]
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
index 2a7e822b28897..b710f26f96ba7 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
@@ -53,14 +53,14 @@ int Point::*pt_member_nested_region = test1();
// Checks for test1()
// CIR-BEFORE: cir.func {{.*}} @_Z5test1v() -> !cir.data_member<!s32i in !rec_Point> attributes {{{.*}}nothrow} {
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.data_member<!s32i in !rec_Point> -> !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
// CIR-BEFORE: %[[MEMBER:.*]] = cir.const #cir.data_member<1> : !cir.data_member<!s32i in !rec_Point>
// CIR-BEFORE: cir.store %[[MEMBER]], %[[RETVAL]] : !cir.data_member<!s32i in !rec_Point>, !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!cir.data_member<!s32i in !rec_Point>>, !cir.data_member<!s32i in !rec_Point>
// CIR-BEFORE: cir.return %[[RET]] : !cir.data_member<!s32i in !rec_Point>
// CIR-AFTER: cir.func {{.*}} @_Z5test1v() -> !s64i attributes {{{.*}}nothrow} {
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s64i>
// CIR-AFTER: %[[OFFSET:.*]] = cir.const #cir.int<4> : !s64i
// CIR-AFTER: cir.store %[[OFFSET]], %[[RETVAL]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!s64i>, !s64i
@@ -103,9 +103,9 @@ int test2(const Point &pt, int Point::*member) {
// CIR-AFTER: cir.func {{.*}} @_Z5test2RK5PointMS_i(
// CIR-AFTER-SAME: %[[PT_ARG:.*]]: !cir.ptr<!rec_Point>
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init const !cir.ptr<!rec_Point> -> !cir.ptr<!cir.ptr<!rec_Point>>
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Point>>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init : !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR-AFTER: cir.store %[[PT_ARG]], %[[PT_ADDR]] : !cir.ptr<!rec_Point>, !cir.ptr<!cir.ptr<!rec_Point>>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[PT:.*]] = cir.load %[[PT_ADDR]] : !cir.ptr<!cir.ptr<!rec_Point>>, !cir.ptr<!rec_Point>
@@ -166,9 +166,9 @@ int test3(const Point *pt, int Point::*member) {
// CIR-AFTER: cir.func {{.*}} @_Z5test3PK5PointMS_i(
// CIR-AFTER-SAME: %[[PT_ARG:.*]]: !cir.ptr<!rec_Point>
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init !cir.ptr<!rec_Point> -> !cir.ptr<!cir.ptr<!rec_Point>>
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-AFTER: %[[PT_ADDR:.*]] = cir.alloca "pt" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Point>>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init : !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR-AFTER: cir.store %[[PT_ARG]], %[[PT_ADDR]] : !cir.ptr<!rec_Point>, !cir.ptr<!cir.ptr<!rec_Point>>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[PT:.*]] = cir.load{{.*}} %[[PT_ADDR]] : !cir.ptr<!cir.ptr<!rec_Point>>, !cir.ptr<!rec_Point>
@@ -224,8 +224,8 @@ auto test4(int Incomplete::*member) -> int Incomplete::* {
// CIR-AFTER: cir.func {{.*}} @_Z5test4M10Incompletei(
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init : !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s64i>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[MEMBER:.*]] = cir.load{{.*}} %[[MEMBER_ADDR]] : !cir.ptr<!s64i>, !s64i
// CIR-AFTER: cir.store %[[MEMBER]], %[[RETVAL_ADDR]] : !s64i, !cir.ptr<!s64i>
@@ -270,9 +270,9 @@ int test5(Incomplete *ic, int Incomplete::*member) {
// CIR-AFTER: cir.func {{.*}} @_Z5test5P10IncompleteMS_i(
// CIR-AFTER-SAME: %[[IC_ARG:.*]]: !cir.ptr<!rec_Incomplete>
// CIR-AFTER-SAME: %[[MEMBER_ARG:.*]]: !s64i
-// CIR-AFTER: %[[IC_ADDR:.*]] = cir.alloca "ic" {{.*}} init !cir.ptr<!rec_Incomplete> -> !cir.ptr<!cir.ptr<!rec_Incomplete>>
-// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init !s64i -> !cir.ptr<!s64i>
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-AFTER: %[[IC_ADDR:.*]] = cir.alloca "ic" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Incomplete>>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init : !cir.ptr<!s64i>
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR-AFTER: cir.store %[[IC_ARG]], %[[IC_ADDR]] : !cir.ptr<!rec_Incomplete>, !cir.ptr<!cir.ptr<!rec_Incomplete>>
// CIR-AFTER: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[IC:.*]] = cir.load{{.*}} %[[IC_ADDR]] : !cir.ptr<!cir.ptr<!rec_Incomplete>>, !cir.ptr<!rec_Incomplete>
@@ -315,7 +315,7 @@ auto test_null() -> int Point::* {
}
// CIR: cir.func {{.*}} @_Z9test_nullv() -> !cir.data_member<!s32i in !rec_Point> {
-// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.data_member<!s32i in !rec_Point> -> !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
+// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_Point>>
// CIR: %[[CONST_NULL:.*]] = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !rec_Point>
// CIR: cir.store %[[CONST_NULL]], %[[RETVAL_ADDR]]
// CIR: %[[RET:.*]] = cir.load %[[RETVAL_ADDR]]
@@ -335,7 +335,7 @@ auto test_null_incomplete() -> int Incomplete::* {
}
// CIR: cir.func {{.*}} @_Z20test_null_incompletev() -> !cir.data_member<!s32i in !rec_Incomplete> {
-// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.data_member<!s32i in !rec_Incomplete> -> !cir.ptr<!cir.data_member<!s32i in !rec_Incomplete>>
+// CIR: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.data_member<!s32i in !rec_Incomplete>>
// CIR: %[[CONST_NULL:.*]] = cir.const #cir.data_member<null> : !cir.data_member<!s32i in !rec_Incomplete>
// CIR: cir.store %[[CONST_NULL]], %[[RETVAL_ADDR]]
// CIR: %[[RET:.*]] = cir.load %[[RETVAL_ADDR]]
diff --git a/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
index b638c3b9ec421..f884be1c5e68b 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
@@ -135,8 +135,8 @@ DerivedMemFunc base_to_derived_zero_offset(Base1MemFunc ptr) {
// CIR-BEFORE: %{{.*}} = cir.derived_method %[[PTR]][0] : !cir.method<!cir.func<(!cir.ptr<!rec_Base1>, !s32i)> in !rec_Base1> -> !cir.method<!cir.func<(!cir.ptr<!rec_Derived>, !s32i)> in !rec_Derived>
// CIR-AFTER: cir.func {{.*}} @_Z27base_to_derived_zero_offsetM5Base1FviE
-// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
-// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.store %{{.*}}, %[[PTR]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[PTR]] : !cir.ptr<!rec_anon_struct>, !rec_anon_struct
// CIR-AFTER: cir.store %[[TMP]], %[[RET]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -202,8 +202,8 @@ Base1MemFunc derived_to_base_zero_offset(DerivedMemFunc ptr) {
// CIR-BEFORE: %{{.*}} = cir.base_method %[[PTR]][0] : !cir.method<!cir.func<(!cir.ptr<!rec_Derived>, !s32i)> in !rec_Derived> -> !cir.method<!cir.func<(!cir.ptr<!rec_Base1>, !s32i)> in !rec_Base1>
// CIR-AFTER: cir.func {{.*}} @_Z27derived_to_base_zero_offsetM7DerivedFviE
-// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
-// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.store %{{.*}}, %[[PTR]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[PTR]] : !cir.ptr<!rec_anon_struct>, !rec_anon_struct
// CIR-AFTER: cir.store %[[TMP]], %[[RET]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
diff --git a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
index 1164220fb511c..5449422ed70b7 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func.cpp
@@ -62,14 +62,14 @@ auto make_non_virtual() -> void (Foo::*)(int) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z16make_non_virtualv() -> !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[METHOD_PTR:.*]] = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[METHOD_PTR]], %[[RETVAL]]
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]]
// CIR-BEFORE: cir.return %[[RET]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-AFTER: cir.func {{.*}} @_Z16make_non_virtualv() -> !rec_anon_struct attributes {{{.*}}nothrow} {
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[METHOD_PTR:.*]] = cir.get_global @[[NONVIRT_RET]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.copy %[[METHOD_PTR]] to %[[RETVAL]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]]
@@ -95,14 +95,14 @@ auto make_virtual() -> void (Foo::*)(int) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z12make_virtualv() -> !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[METHOD_PTR:.*]] = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[METHOD_PTR]], %[[RETVAL]]
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]] : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.return %[[RET]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-AFTER: cir.func {{.*}} @_Z12make_virtualv() -> !rec_anon_struct
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[METHOD_PTR:.*]] = cir.get_global @[[VIRT_RET]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.copy %[[METHOD_PTR]] to %[[RETVAL]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]]
@@ -126,14 +126,14 @@ auto make_null() -> void (Foo::*)(int) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z9make_nullv() -> !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
-// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[METHOD_PTR:.*]] = cir.const #cir.method<null> : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[METHOD_PTR]], %[[RETVAL]]
// CIR-BEFORE: %[[RET:.*]] = cir.load %[[RETVAL]]
// CIR-BEFORE: cir.return %[[RET]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-AFTER: cir.func {{.*}} @_Z9make_nullv() -> !rec_anon_struct
-// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_anon_struct -> !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[METHOD_PTR:.*]] = cir.get_global @[[NULL_RET]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: cir.copy %[[METHOD_PTR]] to %[[RETVAL]] : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.load %[[RETVAL]]
diff --git a/clang/test/CIR/CodeGen/replace-global.cpp b/clang/test/CIR/CodeGen/replace-global.cpp
index 24f946f31f604..2bd3780b03c08 100644
--- a/clang/test/CIR/CodeGen/replace-global.cpp
+++ b/clang/test/CIR/CodeGen/replace-global.cpp
@@ -55,7 +55,7 @@ char *get_ptr_to_element() { return ptrToElement; }
// CIR: cir.global {{.*}} @ptrToElement = #cir.global_view<@gSMulti, [0, 4, 1]> : !cir.ptr<
// CIR: cir.func {{.*}} @_Z15use_as_constantv()
-// CIR: %[[PTR_TO_S:.*]] = cir.alloca "ptrToS" {{.*}} init const !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR: %[[PTR_TO_S:.*]] = cir.alloca "ptrToS" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[GLOBAL_PTR:.*]] = cir.const #cir.global_view<@_ZL2gS> : !cir.ptr<!rec_S>
// CIR: cir.store{{.*}} %[[GLOBAL_PTR]], %[[PTR_TO_S]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
diff --git a/clang/test/CIR/CodeGen/requires-expr.cpp b/clang/test/CIR/CodeGen/requires-expr.cpp
index 7f447ebebed2c..3ef32bee07bf2 100644
--- a/clang/test/CIR/CodeGen/requires-expr.cpp
+++ b/clang/test/CIR/CodeGen/requires-expr.cpp
@@ -11,12 +11,12 @@ template <typename T> void summable(T a) {
}
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store %[[ARG_A:.*]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
// CIR: %[[CONST_TRUE:.*]] = cir.const #true
// CIR: cir.if %[[CONST_TRUE]] {
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TMP_A_1:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[TMP_A_2:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[RESULT:.*]] = cir.add nsw %[[TMP_A_1]], %[[TMP_A_2]] : !s32i
diff --git a/clang/test/CIR/CodeGen/self-assign.c b/clang/test/CIR/CodeGen/self-assign.c
index 59c21733226a2..402269bcdf2a6 100644
--- a/clang/test/CIR/CodeGen/self-assign.c
+++ b/clang/test/CIR/CodeGen/self-assign.c
@@ -19,7 +19,7 @@ void test_self_initialize() {
}
// CIR: cir.func{{.*}} @test_self_initialize()
-// %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// cir.copy %[[S]] to %[[S]] : !cir.ptr<!rec_S>
// LLVM: define{{.*}} void @test_self_initialize()
diff --git a/clang/test/CIR/CodeGen/size-of-vla.cpp b/clang/test/CIR/CodeGen/size-of-vla.cpp
index 19a4e86abce63..a5dc8e3587214 100644
--- a/clang/test/CIR/CodeGen/size-of-vla.cpp
+++ b/clang/test/CIR/CodeGen/size-of-vla.cpp
@@ -10,8 +10,8 @@ void vla_type_with_element_type_of_size_1() {
unsigned long size = sizeof(bool[n]);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
@@ -34,8 +34,8 @@ void vla_type_with_element_type_int() {
unsigned long size = sizeof(int[n]);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
@@ -63,16 +63,16 @@ void vla_expr_element_type_of_size_1() {
unsigned long size = sizeof(arr);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
// CIR: %[[STACK_SAVE:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_SAVE]], %[[SAVED_STACK_ADDR]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} %[[TMP_N]] : !u64i, !cir.bool -> !cir.ptr<!cir.bool>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} size(%[[TMP_N]]) : !cir.ptr<!cir.bool>
// CIR: cir.store {{.*}} %[[TMP_N]], %[[SIZE_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: cir.yield
// CIR: } cleanup normal {
@@ -115,16 +115,16 @@ void vla_expr_element_type_int() {
unsigned long size = sizeof(arr);
}
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
-// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[SAVED_STACK_ADDR:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[SIZE_ADDR:.*]] = cir.alloca "size" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_10:.*]] = cir.const #cir.int<10> : !u64i
// CIR: cir.store {{.*}} %[[CONST_10]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[TMP_N:.*]] = cir.load {{.*}} %[[N_ADDR]] : !cir.ptr<!u64i>, !u64i
// CIR: %[[STACK_SAVE:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_SAVE]], %[[SAVED_STACK_ADDR]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} %[[TMP_N]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR_ADDR:.*]] = cir.alloca "arr" {{.*}} size(%[[TMP_N]]) : !cir.ptr<!s32i>
// CIR: %[[CONST_4:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[SIZE:.*]] = cir.mul nuw %[[CONST_4]], %[[TMP_N]] : !u64i
// CIR: cir.store {{.*}} %[[SIZE]], %[[SIZE_ADDR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/source-loc.cpp b/clang/test/CIR/CodeGen/source-loc.cpp
index 149834d560cf9..786c4e1043494 100644
--- a/clang/test/CIR/CodeGen/source-loc.cpp
+++ b/clang/test/CIR/CodeGen/source-loc.cpp
@@ -69,8 +69,8 @@ void line_column() {
unsigned int b = __builtin_COLUMN();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u32i>
// CIR: %[[CONST_9:.*]] = cir.const #cir.int<68> : !u32i
// CIR: cir.store {{.*}} %[[CONST_9]], %[[A_ADDR]] : !u32i, !cir.ptr<!u32i>
// CIR: %[[CONST_20:.*]] = cir.const #cir.int<20> : !u32i
@@ -92,9 +92,9 @@ void function_file() {
const char *c = __builtin_FILE_NAME();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[FUNC__GV:.*]] = cir.const #cir.global_view<@".str.3"> : !cir.ptr<!s8i>
// CIR: cir.store {{.*}} %[[FUNC__GV]], %[[A_ADDR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[FILE_PATH_GV:.*]] = cir.const #cir.global_view<@".str"> : !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/statement-exprs.c b/clang/test/CIR/CodeGen/statement-exprs.c
index 7ff41bd5c5159..26cace314c159 100644
--- a/clang/test/CIR/CodeGen/statement-exprs.c
+++ b/clang/test/CIR/CodeGen/statement-exprs.c
@@ -13,8 +13,8 @@ int f19(void) {
// LLVM-DAG: @[[TEST3_S:.*]] = private constant %struct.S { i32 1 }
// CIR: cir.func {{.*}} @f19() -> !s32i
-// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.scope {
// CIR: %[[C4:.+]] = cir.const #cir.int<4> : !s32i
// CIR: cir.store {{.*}} %[[C4]], %[[TMP]] : !s32i, !cir.ptr<!s32i>
@@ -64,23 +64,23 @@ int nested(void) {
}
// CIR: cir.func {{.*}} @nested() -> !s32i
-// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP_OUTER:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[TMP_OUTER:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.scope {
// CIR: %[[C123_OUTER:.+]] = cir.const #cir.int<123> : !s32i
// CIR: cir.store {{.*}} %[[C123_OUTER]], %[[TMP_OUTER]] : !s32i, !cir.ptr<!s32i>
// CIR: }
// CIR: %[[LOAD_TMP_OUTER:.+]] = cir.load {{.*}} %[[TMP_OUTER]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.scope {
-// CIR: %[[BAR:.+]] = cir.alloca "bar" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP_BARRET:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[BAR:.+]] = cir.alloca "bar" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[TMP_BARRET:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[C987:.+]] = cir.const #cir.int<987> : !s32i
// CIR: cir.store {{.*}} %[[C987]], %[[BAR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[TMP1:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP2:.+]] = cir.alloca "tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[TMP2:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[ASDF:.+]] = cir.alloca "asdf" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ASDF:.+]] = cir.alloca "asdf" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[C123_INNER:.+]] = cir.const #cir.int<123> : !s32i
// CIR: cir.store {{.*}} %[[C123_INNER]], %[[ASDF]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[LOAD_ASDF:.+]] = cir.load {{.*}} %[[ASDF]] : !cir.ptr<!s32i>, !s32i
@@ -194,9 +194,9 @@ void empty2() { ({ }); }
// Yields an out-of-scope scalar.
void test2() { ({int x = 3; x; }); }
// CIR: cir.func {{.*}} @test2
-// CIR: %[[RETVAL:.+]] = cir.alloca {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.+]] = cir.alloca {{.*}} : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[VAR:.+]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VAR:.+]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// [...]
// CIR: %[[TMP:.+]] = cir.load{{.*}} %[[VAR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.store{{.*}} %[[TMP]], %[[RETVAL]] : !s32i, !cir.ptr<!s32i>
@@ -229,11 +229,11 @@ void test2() { ({int x = 3; x; }); }
struct S { int x; };
int test3() { return ({ struct S s = {1}; s; }).x; }
// CIR: cir.func {{.*}} @test3() -> !s32i
-// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[REF_TMP0:.+]] = cir.alloca "ref.tmp0" {{.*}} !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[REF_TMP0:.+]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_S>
+// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!rec_S>
// CIR: cir.scope {
-// CIR: %[[S:.+]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S:.+]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// CIR: %[[CONST:.*]] = cir.get_global @[[TEST3_S]] : !cir.ptr<!rec_S>
// CIR: cir.copy %[[CONST]] to %[[S]] : !cir.ptr<!rec_S>
// CIR: cir.copy %[[S]] to %[[REF_TMP0]] : !cir.ptr<!rec_S>
diff --git a/clang/test/CIR/CodeGen/static-local-arm-guard.cpp b/clang/test/CIR/CodeGen/static-local-arm-guard.cpp
index d531c3d5aa8dc..156c6f70c8b8c 100644
--- a/clang/test/CIR/CodeGen/static-local-arm-guard.cpp
+++ b/clang/test/CIR/CodeGen/static-local-arm-guard.cpp
@@ -56,7 +56,7 @@ inline int word_guard() {
}
// CIR: cir.func {{.*}} @_Z10word_guardv()
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[B:.*]] = cir.get_global static_local @_ZZ10word_guardvE1b : !cir.ptr<!s32i>
// CIR: %[[GUARD:.*]] = cir.get_global @_ZGVZ10word_guardvE1b : !cir.ptr<!s64i>
// CIR: %[[GUARD_BYTE_PTR:.*]] = cir.cast bitcast %[[GUARD]] : !cir.ptr<!s64i> -> !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/static-local.cpp b/clang/test/CIR/CodeGen/static-local.cpp
index 4ace38a4cfdf2..3279560df3d35 100644
--- a/clang/test/CIR/CodeGen/static-local.cpp
+++ b/clang/test/CIR/CodeGen/static-local.cpp
@@ -188,7 +188,7 @@ void references_param_and_previous(int param) {
static int refs_magic_static = magic_static;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z29references_param_and_previousi
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_MAG_STATIC:.*]] = cir.get_global static_local @_ZZ29references_param_and_previousiE12magic_static : !cir.ptr<!s32i>
//
// CIR-BEFORE-LPP: cir.local_init static_local @_ZZ29references_param_and_previousiE12magic_static ctor {
@@ -279,9 +279,9 @@ void multi_refs(int one, int two, int, int three, int, int four, int) {
static A magic_static = one + three + four + bar();
static A refs_magic_static = magic_static;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z10multi_refsiiiiiii(
-// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca "three" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: %[[FOUR_ALLOCA:.*]] = cir.alloca "four" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca "three" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: %[[FOUR_ALLOCA:.*]] = cir.alloca "four" {{.*}} init : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_MS:.*]] = cir.get_global static_local @_ZZ10multi_refsiiiiiiiE12magic_static : !cir.ptr<!rec_A>
// CIR-BEFORE-LPP: cir.local_init static_local @_ZZ10multi_refsiiiiiiiE12magic_static ctor {
//
@@ -387,10 +387,10 @@ void InMember::mem_func(int one, int two, int, int three) {
int some_local = mem_get_int();
static int magic_static = three + mem_get_int() + one + some_local;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_ZN8InMember8mem_funcEiiii(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_InMember> -> !cir.ptr<!cir.ptr<!rec_InMember>>
-// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca "three" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: %[[LOCAL_ALLOCA:.*]] = cir.alloca "some_local" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_InMember>>
+// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: %[[THREE_ALLOCA:.*]] = cir.alloca "three" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: %[[LOCAL_ALLOCA:.*]] = cir.alloca "some_local" {{.*}} init : !cir.ptr<!s32i>
// CIR-BOTH: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_InMember>>, !cir.ptr<!rec_InMember>
// CIR-BOTH: %[[GET_INT:.*]] = cir.call @_ZN8InMember11mem_get_intEv(%[[THIS_LOAD]]) : (!cir.ptr<!rec_InMember>{{.*}}) -> (!s32i {llvm.noundef})
// CIR-BOTH: cir.store{{.*}} %[[GET_INT]], %[[LOCAL_ALLOCA]] : !s32i, !cir.ptr<!s32i>
@@ -461,7 +461,7 @@ void InMember::mem_func(int one, int two, int, int three) {
void self_ref(int one) {
static int magic_static = magic_static + one;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z8self_refi(
-// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[ONE_ALLOCA:.*]] = cir.alloca "one" {{.*}} init : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_MS:.*]] = cir.get_global static_local @_ZZ8self_refiE12magic_static : !cir.ptr<!s32i>
//
// CIR-BEFORE-LPP: cir.local_init static_local @_ZZ8self_refiE12magic_static ctor {
@@ -630,8 +630,8 @@ int referenced_inside() {
auto lam = []() { return static_local; };
return lam();
// CIR-BOTH-LABEL: cir.func no_inline lambda internal private dso_local @_ZZ17referenced_insidevENK3$_0clEv(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!{{.*}}> -> !cir.ptr<!cir.ptr<!{{.*}}>>
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!{{.*}}>>
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_THIS:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!{{.*}}>>, !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global static_local @_ZZ17referenced_insidevE12static_local : !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_SL:.*]] = cir.load {{.*}}%[[GET_SL]] : !cir.ptr<!s32i>, !s32i
@@ -641,8 +641,8 @@ int referenced_inside() {
// CIR-BOTH: }
//
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z17referenced_insidev()
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca "lam" {{.*}} !{{.*}} -> !cir.ptr<!{{.*}}>
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca "lam" {{.*}} : !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global static_local @_ZZ17referenced_insidevE12static_local : !cir.ptr<!s32i>
// CIR-BEFORE-LLP: cir.local_init static_local @_ZZ17referenced_insidevE12static_local ctor {
//
@@ -712,8 +712,8 @@ int referenced_inside_const() {
auto lam = []() { return static_local; };
return lam();
// CIR-BOTH-LABEL: cir.func no_inline lambda internal private dso_local @_ZZ23referenced_inside_constvENK3$_0clEv(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!{{.*}}> -> !cir.ptr<!cir.ptr<!{{.*}}>>
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!{{.*}}>>
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_THIS:.*]] = cir.load %[[THIS_ALLOCA]] : !cir.ptr<!cir.ptr<!{{.*}}>>, !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global @_ZZ23referenced_inside_constvE12static_local : !cir.ptr<!s32i>
// CIR-BOTH: %[[LOAD_SL:.*]] = cir.load {{.*}}%[[GET_SL]] : !cir.ptr<!s32i>, !s32i
@@ -723,8 +723,8 @@ int referenced_inside_const() {
// CIR-BOTH: }
//
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z23referenced_inside_constv()
-// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca "lam" {{.*}} !{{.*}} -> !cir.ptr<!{{.*}}>
+// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR-BOTH: %[[LAMBDA_ALLOCA:.*]] = cir.alloca "lam" {{.*}} : !cir.ptr<!{{.*}}>
// CIR-BOTH: %[[GET_SL:.*]] = cir.get_global @_ZZ23referenced_inside_constvE12static_local : !cir.ptr<!s32i>
// CIR-BOTH-NOT: static_local
// CIR-BOTH-NOT: atomic
diff --git a/clang/test/CIR/CodeGen/stmt-expr.cpp b/clang/test/CIR/CodeGen/stmt-expr.cpp
index 2fdb502fb73fb..f78aa0ed25a11 100644
--- a/clang/test/CIR/CodeGen/stmt-expr.cpp
+++ b/clang/test/CIR/CodeGen/stmt-expr.cpp
@@ -21,10 +21,10 @@ void test1() {
}
// CIR: cir.func {{.*}} @_Z5test1v()
-// CIR: %[[REF_TMP0:.+]] = cir.alloca "ref.tmp0" {{.*}} !rec_A -> !cir.ptr<!rec_A>
-// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[REF_TMP0:.+]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_A>
+// CIR: %[[TMP:.+]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!rec_A>
// CIR: cir.scope {
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init !rec_A -> !cir.ptr<!rec_A>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_A>
// CIR: cir.call @_ZN1AC2Ev(%[[A]]) : (!cir.ptr<!rec_A> {{.*}}) -> ()
// CIR: cir.call @_ZN1AC2ERS_(%[[REF_TMP0]], %[[A]]) : (!cir.ptr<!rec_A> {{.*}}, !cir.ptr<!rec_A> {{.*}}) -> ()
// CIR: }
@@ -63,7 +63,7 @@ void cleanup() {
// CIR: cir.func {{.*}} @_Z7cleanupv()
// CIR: cir.scope {
-// CIR: %[[WD:.+]] = cir.alloca "wd" {{.*}} !rec_with_dtor -> !cir.ptr<!rec_with_dtor>
+// CIR: %[[WD:.+]] = cir.alloca "wd" {{.*}} : !cir.ptr<!rec_with_dtor>
// CIR: cir.cleanup.scope {
// CIR: cir.yield
// CIR: } cleanup normal {
@@ -92,10 +92,10 @@ void gnu_statement_extension() {
float b = __real__ ({float _Complex a; a;});
}
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[TMP_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
+// CIR: %[[TMP_ADDR:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.scope {
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: cir.store {{.*}} %[[TMP_A]], %[[TMP_ADDR]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CIR: }
diff --git a/clang/test/CIR/CodeGen/string-literals.cpp b/clang/test/CIR/CodeGen/string-literals.cpp
index 8f5f5db938d57..896016b0f39ef 100644
--- a/clang/test/CIR/CodeGen/string-literals.cpp
+++ b/clang/test/CIR/CodeGen/string-literals.cpp
@@ -58,7 +58,7 @@ decltype(auto) returns_literal() {
}
// CIR: cir.func{{.*}} @_Z15returns_literalv() -> (!cir.ptr<!cir.array<!s8i x 5>>{{.*}})
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s8i x 5>>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.array<!s8i x 5>>>
// CIR: %[[STR_ADDR:.*]] = cir.get_global @[[STR5_GLOBAL]] : !cir.ptr<!cir.array<!s8i x 5>>
// CIR: cir.store{{.*}} %[[STR_ADDR]], %[[RET_ADDR]]
// CIR: %[[RET:.*]] = cir.load %[[RET_ADDR]]
diff --git a/clang/test/CIR/CodeGen/struct-init.cpp b/clang/test/CIR/CodeGen/struct-init.cpp
index 6b55ee54bd1fe..fe83719ec054e 100644
--- a/clang/test/CIR/CodeGen/struct-init.cpp
+++ b/clang/test/CIR/CodeGen/struct-init.cpp
@@ -79,8 +79,8 @@ void init() {
}
// CIR: cir.func{{.*}} @_Z4initv()
-// CIR: %[[S1:.*]] = cir.alloca "s1" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[S2:.*]] = cir.alloca "s2" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S1:.*]] = cir.alloca "s1" {{.*}} init : !cir.ptr<!rec_S>
+// CIR: %[[S2:.*]] = cir.alloca "s2" {{.*}} init : !cir.ptr<!rec_S>
// CIR: %[[CONST_1:.*]] = cir.get_global @[[INIT_S1]] : !cir.ptr<!rec_S>
// CIR: cir.copy %[[CONST_1]] to %[[S1]] : !cir.ptr<!rec_S>
// CIR: %[[CONST_2:.*]] = cir.get_global @[[INIT_S2]] : !cir.ptr<!rec_S>
@@ -106,9 +106,9 @@ void init_var(int a, int b) {
}
// CIR: cir.func{{.*}} @_Z8init_varii(%[[A_ARG:.*]]: !s32i {{.*}}, %[[B_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// CIR: cir.store{{.*}} %[[A_ARG]], %[[A_PTR]]
// CIR: cir.store{{.*}} %[[B_ARG]], %[[B_PTR]]
// CIR: %[[S_A:.*]] = cir.get_member %[[S]][0] {name = "a"}
@@ -154,10 +154,10 @@ void init_expr(int a, int b, int c) {
}
// CIR: cir.func{{.*}} @_Z9init_expriii(%[[A_ARG:.*]]: !s32i {{.*}}, %[[B_ARG:.*]]: !s32i {{.*}}, %[[C_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[C_PTR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[A_PTR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_PTR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[C_PTR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// CIR: cir.store{{.*}} %[[A_ARG]], %[[A_PTR]]
// CIR: cir.store{{.*}} %[[B_ARG]], %[[B_PTR]]
// CIR: cir.store{{.*}} %[[C_ARG]], %[[C_PTR]]
@@ -230,7 +230,7 @@ void cxx_default_init_with_struct_field() {
Parent p = Parent{};
}
-// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init !rec_Parent -> !cir.ptr<!rec_Parent>
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!rec_Parent>
// CIR: %[[P_ELEM_0_PTR:.*]] = cir.get_member %[[P_ADDR]][0] {name = "a"} : !cir.ptr<!rec_Parent> -> !cir.ptr<!s32i>
// CIR: %[[METHOD_CALL:.*]] = cir.call @_ZZ34cxx_default_init_with_struct_fieldvEN6Parent4getAEv(%[[P_ADDR]]) : (!cir.ptr<!rec_Parent>{{.*}}) -> (!s32i {llvm.noundef})
// CIR: cir.store{{.*}} %[[METHOD_CALL]], %[[P_ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c
index e2f92255625db..c4c38519599bf 100644
--- a/clang/test/CIR/CodeGen/struct.c
+++ b/clang/test/CIR/CodeGen/struct.c
@@ -167,7 +167,7 @@ void f(void) {
}
// CIR: cir.func{{.*}} @f()
-// CIR-NEXT: cir.alloca "p" align(8) !cir.ptr<!rec_IncompleteS> -> !cir.ptr<!cir.ptr<!rec_IncompleteS>>
+// CIR-NEXT: cir.alloca "p" align(8) : !cir.ptr<!cir.ptr<!rec_IncompleteS>>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @f()
@@ -184,7 +184,7 @@ void f2(void) {
}
// CIR: cir.func{{.*}} @f2()
-// CIR-NEXT: cir.alloca "s" align(4) !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR-NEXT: cir.alloca "s" align(4) : !cir.ptr<!rec_CompleteS>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @f2()
diff --git a/clang/test/CIR/CodeGen/struct.cpp b/clang/test/CIR/CodeGen/struct.cpp
index 3bfc583f6ccb9..4a80dbcb25ebb 100644
--- a/clang/test/CIR/CodeGen/struct.cpp
+++ b/clang/test/CIR/CodeGen/struct.cpp
@@ -37,7 +37,7 @@ void f(void) {
}
// CIR: cir.func{{.*}} @_Z1fv()
-// CIR-NEXT: cir.alloca "p" {{.*}} !cir.ptr<!rec_IncompleteS> -> !cir.ptr<!cir.ptr<!rec_IncompleteS>>
+// CIR-NEXT: cir.alloca "p" {{.*}} : !cir.ptr<!cir.ptr<!rec_IncompleteS>>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @_Z1fv()
@@ -54,7 +54,7 @@ char f2(CompleteS &s) {
}
// CIR: cir.func{{.*}} @_Z2f2R9CompleteS(%[[ARG_S:.*]]: !cir.ptr<!rec_CompleteS>{{.*}})
-// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<!rec_CompleteS> -> !cir.ptr<!cir.ptr<!rec_CompleteS>>
+// CIR: %[[S_ADDR:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_CompleteS>>
// CIR: cir.store %[[ARG_S]], %[[S_ADDR]]
// CIR: %[[S_REF:.*]] = cir.load{{.*}} %[[S_ADDR]]
// CIR: %[[S_ADDR2:.*]] = cir.get_member %[[S_REF]][1] {name = "b"}
@@ -89,7 +89,7 @@ void f3() {
}
// CIR: cir.func{{.*}} @_Z2f3v()
-// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} !rec_Outer -> !cir.ptr<!rec_Outer>
+// CIR: %[[O:.*]] = cir.alloca "o" {{.*}} : !cir.ptr<!rec_Outer>
// CIR: %[[O_I:.*]] = cir.get_member %[[O]][0] {name = "i"}
// CIR: %[[O_I_N:.*]] = cir.get_member %[[O_I]][0] {name = "n"}
@@ -114,8 +114,8 @@ void paren_expr() {
}
// CIR: cir.func{{.*}} @_Z10paren_exprv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !rec_Point -> !cir.ptr<!rec_Point>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_Point>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_Point>
// CIR: %[[CONST:.*]] = cir.get_global @[[PAREN_A]] : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]] : !cir.ptr<!rec_Point>
// CIR: cir.copy %[[A_ADDR]] to %[[B_ADDR]] : !cir.ptr<!rec_Point>
@@ -139,9 +139,9 @@ void choose_expr() {
}
// CIR: cir.func{{.*}} @_Z11choose_exprv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_CompleteS>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!rec_CompleteS>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[A_ADDR]] to %[[C_ADDR]] : !cir.ptr<!rec_CompleteS>
// LLVM: define{{.*}} void @_Z11choose_exprv()
@@ -164,10 +164,10 @@ void generic_selection() {
}
// CIR: cir.func{{.*}} @_Z17generic_selectionv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_CompleteS>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!rec_CompleteS>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[A_ADDR]] to %[[D_ADDR]] : !cir.ptr<!rec_CompleteS>
// LLVM: define{{.*}} void @_Z17generic_selectionv()
@@ -192,8 +192,8 @@ void designated_init_update_expr() {
} b = {a, .c.a = 1};
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !rec_Container -> !cir.ptr<!rec_Container>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_CompleteS>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_Container>
// CIR: %[[C_ADDR:.*]] = cir.get_member %[[B_ADDR]][0] {name = "c"} : !cir.ptr<!rec_Container> -> !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[A_ADDR]] to %[[C_ADDR]] : !cir.ptr<!rec_CompleteS>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[C_ADDR]][0] {name = "a"} : !cir.ptr<!rec_CompleteS> -> !cir.ptr<!s32i>
@@ -223,7 +223,7 @@ void atomic_init() {
}
// CIR: cir.func{{.*}} @_Z11atomic_initv()
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_CompleteS>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[A_ADDR]][0] {name = "a"} : !cir.ptr<!rec_CompleteS> -> !cir.ptr<!s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[CONST_0]], %[[ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
@@ -249,7 +249,7 @@ void unary_extension() {
CompleteS a = __extension__ CompleteS();
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: %[[ZERO_INIT:.*]] = cir.get_global @[[UNARY_A:.*]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[ZERO_INIT]] to %[[A_ADDR]] : !cir.ptr<!rec_CompleteS>
@@ -264,7 +264,7 @@ void bin_comma() {
}
// CIR: cir.func{{.*}} @_Z9bin_commav()
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: %[[CONST:.*]] = cir.get_global @[[COMMA_A:.*]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]] : !cir.ptr<!rec_CompleteS>
@@ -278,7 +278,7 @@ void bin_comma() {
void compound_literal_expr() { CompleteS a = (CompleteS){}; }
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: %[[CONST:.*]] = cir.get_global @[[COMPLIT_A:.*]] : !cir.ptr<!rec_CompleteS>
// CIR: cir.copy %[[CONST]] to %[[A_ADDR]] : !cir.ptr<!rec_CompleteS>
@@ -298,8 +298,8 @@ void struct_with_const_member_expr() {
int a = (StructWithConstMember){}.a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[REF_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_StructWithConstMember -> !cir.ptr<!rec_StructWithConstMember>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[REF_ADDR:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_StructWithConstMember>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[REF_ADDR]][0] {name = "a"} : !cir.ptr<!rec_StructWithConstMember> -> !cir.ptr<!u8i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s32i
// CIR: %[[SET_BF:.*]] = cir.set_bitfield{{.*}} (#bfi_a, %[[ELEM_0_PTR]] : !cir.ptr<!u8i>, %[[CONST_0]] : !s32i) -> !s32i
@@ -327,7 +327,7 @@ void struct_with_const_member_expr() {
void function_arg_with_default_value(CompleteS a = {1, 2}) {}
-// CIR: %[[ARG_ADDR:.*]] = cir.alloca "a" {{.*}} init !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[ARG_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!rec_CompleteS>
// CIR: cir.store %{{.*}}, %[[ARG_ADDR]] : !rec_CompleteS, !cir.ptr<!rec_CompleteS>
// LLVM: %[[ARG_ADDR:.*]] = alloca %struct.CompleteS, i64 1, align 4
@@ -340,7 +340,7 @@ void calling_function_with_default_values() {
function_arg_with_default_value();
}
-// CIR: %[[AGG_ADDR:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_CompleteS -> !cir.ptr<!rec_CompleteS>
+// CIR: %[[AGG_ADDR:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_CompleteS>
// CIR: %[[ELEM_0_PTR:.*]] = cir.get_member %[[AGG_ADDR]][0] {name = "a"} : !cir.ptr<!rec_CompleteS> -> !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[ELEM_0_PTR]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/switch.cpp b/clang/test/CIR/CodeGen/switch.cpp
index a665945265479..9b608ba6985da 100644
--- a/clang/test/CIR/CodeGen/switch.cpp
+++ b/clang/test/CIR/CodeGen/switch.cpp
@@ -27,7 +27,7 @@ void sw1(int a) {
// CIR-NEXT: cir.break
// CIR: cir.case(equal, [#cir.int<2> : !s32i]) {
// CIR: cir.scope {
-// CIR: cir.alloca "yolo" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: cir.alloca "yolo" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.break
// LLVM: define{{.*}} void @_Z3sw1i
@@ -99,8 +99,8 @@ void sw2(int a) {
// CIR: cir.func{{.*}} @_Z3sw2i
// CIR: cir.scope {
-// CIR-NEXT: %[[YOLO:.*]] = cir.alloca "yolo" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[FOMO:.*]] = cir.alloca "fomo" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-NEXT: %[[YOLO:.*]] = cir.alloca "yolo" {{.*}} init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[FOMO:.*]] = cir.alloca "fomo" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.switch(%[[COND:.*]] : !s32i) {
// CIR-NEXT: cir.case(equal, [#cir.int<3> : !s32i]) {
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
@@ -405,7 +405,7 @@ void sw7(int a) {
}
// CIR: cir.func{{.*}} @_Z3sw7i
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.switch(%[[A:.*]] : !s32i)
// CIR-NEXT: cir.case(equal, [#cir.int<0> : !s32i]) {
// CIR-NEXT: cir.yield
@@ -978,7 +978,7 @@ void sw15(int x) {
}
// CIR: cir.func{{.*}} @_Z4sw15i
-// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.switch
// CIR-NEXT: cir.case(equal, [#cir.int<1> : !s32i]) {
// CIR-NEXT: cir.yield
diff --git a/clang/test/CIR/CodeGen/switch_flat_op.cpp b/clang/test/CIR/CodeGen/switch_flat_op.cpp
index e41266534df74..cb8b3ea74649c 100644
--- a/clang/test/CIR/CodeGen/switch_flat_op.cpp
+++ b/clang/test/CIR/CodeGen/switch_flat_op.cpp
@@ -19,7 +19,7 @@ void swf(int a) {
}
// BEFORE: cir.func{{.*}} @_Z3swfi
-// BEFORE: %[[VAR_B:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+// BEFORE: %[[VAR_B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// BEFORE: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
// BEFORE: cir.switch(%[[COND:.*]] : !s32i) {
// BEFORE: cir.case(equal, [#cir.int<3> : !s32i]) {
@@ -45,9 +45,9 @@ void swf(int a) {
// BEFORE: cir.return
// AFTER: cir.func{{.*}} @_Z3swfi
-// AFTER: %[[VAR_A:.*]] = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+// AFTER: %[[VAR_A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// AFTER: cir.store{{.*}} %arg0, %[[VAR_A]] : !s32i, !cir.ptr<!s32i>
-// AFTER: %[[VAR_B:.*]] = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+// AFTER: %[[VAR_B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// AFTER: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
// AFTER: cir.store{{.*}} %[[CONST_3]], %[[VAR_B]] : !s32i, !cir.ptr<!s32i>
// AFTER: cir.switch.flat %[[COND:.*]] : !s32i, ^bb[[#BB6:]] [
diff --git a/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp b/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp
index f9faa948d31bc..5f0fc4d830d2c 100644
--- a/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp
+++ b/clang/test/CIR/CodeGen/temp-param-obj-decl.cpp
@@ -26,7 +26,7 @@ const auto *ptr = get_ptr<HasMem{3}>();
template<HasMem m>
int get_x() { return m.x; }
// CIR-LABEL: cir.func {{.*}}@_Z5get_xIXtl6HasMemLi1EEEEiv()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// Note: This is emitted as an 'ignored' expression, but we cannot omit it,
// since it might be used in an example like below.
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZTAXtl6HasMemLi1EEE : !cir.ptr<!rec_HasMem>
@@ -43,7 +43,7 @@ int get_x() { return m.x; }
template<HasMem m>
HasMem get_m() { return m; }
// CIR-LABEL: cir.func {{.*}}@_Z5get_mIXtl6HasMemLi2EEEES0_v()
-// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(4) !rec_HasMem -> !cir.ptr<!rec_HasMem>
+// CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!rec_HasMem>
// CIR: %[[GET_GLOB:.*]] = cir.get_global @_ZTAXtl6HasMemLi2EEE : !cir.ptr<!rec_HasMem>
// CIR: cir.copy %[[GET_GLOB]] to %[[RET_ALLOCA]] : !cir.ptr<!rec_HasMem>
//
diff --git a/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp b/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp
index 73218a5ed02f3..567675a223ca3 100644
--- a/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp
+++ b/clang/test/CIR/CodeGen/temporary-materialization-adjust.cpp
@@ -11,8 +11,8 @@ void Field() {
const int &r = Base().x;
}
// CIR-LABEL: cir.func {{.*}}@_Z5Fieldv()
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} !rec_Base -> !cir.ptr<!rec_Base>
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_Base>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GET_MEM:.*]] = cir.get_member %[[TEMP_ALLOCA]][0] {name = "x"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: cir.store align(8) %[[GET_MEM]], %[[R_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -26,9 +26,9 @@ void MemPtr(int Base::*mp) {
const int &r = Base().*mp;
}
// CIR-LABEL: cir.func {{.*}}@_Z6MemPtrM4Basei
-// CIR: %[[MP_ALLOCA:.*]] = cir.alloca "mp" align(8) init !s64i -> !cir.ptr<!s64i>
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) !rec_Base -> !cir.ptr<!rec_Base>
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" align(8) init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[MP_ALLOCA:.*]] = cir.alloca "mp" align(8) init : !cir.ptr<!s64i>
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) : !cir.ptr<!rec_Base>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" align(8) init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[ARG_LOAD:.*]] = cir.load align(8) %[[MP_ALLOCA]] : !cir.ptr<!s64i>, !s64i
// CIR: %[[TEMP_LOAD:.*]] = cir.cast bitcast %[[TEMP_ALLOCA]] : !cir.ptr<!rec_Base> -> !cir.ptr<!s8i>
// CIR: %[[STRIDE:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ARG_LOAD]] : (!cir.ptr<!s8i>, !s64i) -> !cir.ptr<!s8i>
@@ -48,8 +48,8 @@ void DerivedToBase() {
const int &r = Derived().x;
}
// CIR-LABEL: cir.func {{.*}}@_Z13DerivedToBasev()
-// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) !rec_Derived -> !cir.ptr<!rec_Derived>
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" align(8) init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[TEMP_ALLOCA:.*]] = cir.alloca "ref.tmp0" align(4) : !cir.ptr<!rec_Derived>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" align(8) init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TEMP_ALLOCA]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: %[[GET_MEM:.*]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: cir.store align(8) %[[GET_MEM]], %[[R_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGen/temporary-materialization.cpp b/clang/test/CIR/CodeGen/temporary-materialization.cpp
index 04beef92628b3..eb8615f6513ea 100644
--- a/clang/test/CIR/CodeGen/temporary-materialization.cpp
+++ b/clang/test/CIR/CodeGen/temporary-materialization.cpp
@@ -13,8 +13,8 @@ int test() {
}
// CIR: cir.func {{.*}} @_Z4testv()
-// CIR: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[X:.*]] = cir.alloca "x" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[X:.*]] = cir.alloca "x" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[TEMP_VALUE:.*]] = cir.call @_Z8make_intv() : () -> (!s32i {llvm.noundef})
// CIR-NEXT: cir.store{{.*}} %[[TEMP_VALUE]], %[[TEMP_SLOT]]
// CIR-NEXT: cir.store{{.*}} %[[TEMP_SLOT]], %[[X]]
@@ -44,10 +44,10 @@ int test_scoped() {
}
// CIR: cir.func {{.*}} @_Z11test_scopedv()
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR-NEXT: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR-NEXT: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[TEMP_VALUE:.*]] = cir.call @_Z8make_intv() : () -> (!s32i {llvm.noundef})
// CIR-NEXT: cir.store{{.*}} %[[TEMP_VALUE]], %[[TEMP_SLOT]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[TEMP_SLOT]], %[[Y_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGen/ternary-throw.cpp b/clang/test/CIR/CodeGen/ternary-throw.cpp
index 0f58e2ab5efa4..ef9f2aaea4c9f 100644
--- a/clang/test/CIR/CodeGen/ternary-throw.cpp
+++ b/clang/test/CIR/CodeGen/ternary-throw.cpp
@@ -11,8 +11,8 @@ const int& test_cond_throw_false(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z21test_cond_throw_falseb(
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const : !cir.ptr<!s32i>
// CIR: %[[TEN:.*]] = cir.const #cir.int<10> : !s32i
// CIR: cir.store{{.*}} %[[TEN]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
@@ -74,8 +74,8 @@ const int& test_cond_throw_true(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z20test_cond_throw_trueb(
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const : !cir.ptr<!s32i>
// CIR: %[[TEN:.*]] = cir.const #cir.int<10> : !s32i
// CIR: cir.store{{.*}} %[[TEN]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
@@ -138,7 +138,7 @@ const int& test_cond_const_true_throw_false() {
}
// CIR-LABEL: cir.func{{.*}} @_Z32test_cond_const_true_throw_falsev(
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const : !cir.ptr<!s32i>
// CIR: %[[TWENTY:.*]] = cir.const #cir.int<20> : !s32i
// CIR: cir.store{{.*}} %[[TWENTY]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
@@ -170,7 +170,7 @@ const int& test_cond_const_false_throw_true() {
}
// CIR-LABEL: cir.func{{.*}} @_Z32test_cond_const_false_throw_truev(
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init const : !cir.ptr<!s32i>
// CIR: %[[THIRTY:.*]] = cir.const #cir.int<30> : !s32i
// CIR: cir.store{{.*}} %[[THIRTY]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
@@ -201,8 +201,8 @@ const int &test_cond_const_true_throw_true() {
}
// CIR-LABEL: cir.func{{.*}} @_Z31test_cond_const_true_throw_truev(
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init const !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init const : !cir.ptr<!s32i>
// CIR: %[[CONST_30:.*]] = cir.const #cir.int<30> : !s32i
// CIR: cir.store{{.*}} %[[CONST_30]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[EXCEPTION:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i>
@@ -245,9 +245,9 @@ int test_agg_cond_throw_false(bool flag, struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z25test_agg_cond_throw_falseb2s6S_(
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init : !cir.ptr<!rec_s6>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[COND_RES:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: cir.yield %[[A1]] : !cir.ptr<!rec_s6>
@@ -310,9 +310,9 @@ int test_agg_cond_throw_true(bool flag, struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z24test_agg_cond_throw_trueb2s6S_(
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init : !cir.ptr<!rec_s6>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[COND_RES:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: %[[EXC:.*]] = cir.alloc.exception{{.*}} -> !cir.ptr<!s32i>
@@ -375,8 +375,8 @@ const int test_agg_cond_const_true_throw_false(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z36test_agg_cond_const_true_throw_false2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init : !cir.ptr<!rec_s6>
// CIR-NOT: cir.ternary
// CIR-NOT: cir.throw
// CIR: %[[F0:.*]] = cir.get_member %[[A1]][0] {name = "f0"} : !cir.ptr<!rec_s6> -> !cir.ptr<!s32i>
@@ -411,8 +411,8 @@ const int test_agg_cond_const_true_throw_true(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z35test_agg_cond_const_true_throw_true2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init : !cir.ptr<!rec_s6>
// CIR: %[[EXC:.*]] = cir.alloc.exception{{.*}} -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[EXC]] : !s32i, !cir.ptr<!s32i>
@@ -451,8 +451,8 @@ const int test_agg_cond_const_false_throw_false(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z37test_agg_cond_const_false_throw_false2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init : !cir.ptr<!rec_s6>
// CIR: %[[EXC:.*]] = cir.alloc.exception{{.*}} -> !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[EXC]] : !s32i, !cir.ptr<!s32i>
@@ -491,8 +491,8 @@ const int test_agg_cond_const_false_throw_true(struct s6 a1, struct s6 a2) {
}
// CIR-LABEL: cir.func{{.*}} @_Z36test_agg_cond_const_false_throw_true2s6S_(
-// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
-// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init !rec_s6 -> !cir.ptr<!rec_s6>
+// CIR: %[[A1:.*]] = cir.alloca "a1" {{.*}} init : !cir.ptr<!rec_s6>
+// CIR: %[[A2:.*]] = cir.alloca "a2" {{.*}} init : !cir.ptr<!rec_s6>
// CIR-NOT: cir.ternary
// CIR-NOT: cir.throw
// CIR: %[[F0:.*]] = cir.get_member %[[A1]][0] {name = "f0"} : !cir.ptr<!rec_s6> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/ternary.cpp b/clang/test/CIR/CodeGen/ternary.cpp
index 8d6823048dc4c..061794c7835bd 100644
--- a/clang/test/CIR/CodeGen/ternary.cpp
+++ b/clang/test/CIR/CodeGen/ternary.cpp
@@ -11,8 +11,8 @@ int x(int y) {
// CIR-LABEL: cir.func{{.*}} @_Z1xi(
// CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}) -> (!s32i{{.*}}) attributes {{{.*}}nothrow} {
-// CIR: [[Y:%.+]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: [[Y:%.+]] = cir.alloca "y" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], [[Y]] : !s32i, !cir.ptr<!s32i>
// CIR: [[YVAL:%.+]] = cir.load{{.*}} [[Y]] : !cir.ptr<!s32i>, !s32i
// CIR: [[ZERO:%.+]] = cir.const #cir.int<0> : !s32i
@@ -53,9 +53,9 @@ int foo(int a, int b) {
// CIR-LABEL: cir.func{{.*}} @_Z3fooii(
// CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}, %[[ARG1:.*]]: !s32i {{.*}}) -> (!s32i{{.*}}) attributes {{{.*}}nothrow} {
-// CIR: [[A:%.+]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[B:%.+]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: [[A:%.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[B:%.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], [[A]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %[[ARG1]], [[B]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
@@ -152,9 +152,9 @@ void test_cond_lvalue_assign(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z23test_cond_lvalue_assignb(
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]]
// CIR: %[[TERNARY_PTR:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: cir.yield %[[A]] : !cir.ptr<!s32i>
@@ -200,9 +200,9 @@ int& test_cond_lvalue_ref(bool cond, int x, int y) {
}
// CIR-LABEL: cir.func{{.*}} @_Z20test_cond_lvalue_refbii(
-// CIR: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[X:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[Y:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[COND_VAL:.*]] = cir.load{{.*}} %[[COND]]
// CIR: %[[REF_PTR:.*]] = cir.ternary(%[[COND_VAL]], true {
// CIR: cir.yield %[[X]] : !cir.ptr<!s32i>
@@ -255,9 +255,9 @@ void test_cond_lvalue_compound(bool flag) {
}
// CIR-LABEL: cir.func{{.*}} @_Z25test_cond_lvalue_compoundb(
-// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init !cir.bool -> !cir.ptr<!cir.bool>
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[FLAG:.*]] = cir.alloca "flag" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[FLAG_VAL:.*]] = cir.load{{.*}} %[[FLAG]]
// CIR: %[[LVAL_PTR:.*]] = cir.ternary(%[[FLAG_VAL]], true {
// CIR: cir.yield %[[A]] : !cir.ptr<!s32i>
@@ -312,8 +312,8 @@ void test_cond_const_true_lvalue() {
}
// CIR-LABEL: cir.func{{.*}} @_Z27test_cond_const_true_lvaluev(
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
// CIR: %[[NINETYNINE:.*]] = cir.const #cir.int<99> : !s32i
// CIR: cir.store{{.*}} %[[NINETYNINE]], %[[A]] : !s32i, !cir.ptr<!s32i>
@@ -338,8 +338,8 @@ void test_cond_const_false_lvalue() {
}
// CIR-LABEL: cir.func{{.*}} @_Z28test_cond_const_false_lvaluev(
-// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR-NOT: cir.ternary
// CIR: %[[EIGHTYEIGHT:.*]] = cir.const #cir.int<88> : !s32i
// CIR: cir.store{{.*}} %[[EIGHTYEIGHT]], %[[B]] : !s32i, !cir.ptr<!s32i>
@@ -362,7 +362,7 @@ void ternary_void(bool b) {
}
// CIR-LABEL: cir.func{{.*}}@_Z12ternary_voidb
-// CIR: %[[ARG:.*]] = cir.alloca {{.*}} !cir.bool
+// CIR: %[[ARG:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_ARG:.*]] = cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.bool>
// CIR: cir.ternary(%[[LOAD_ARG]], true {
// CIR-NEXT: cir.call @_Z3foov()
diff --git a/clang/test/CIR/CodeGen/thread-local-in-func.cpp b/clang/test/CIR/CodeGen/thread-local-in-func.cpp
index 23bb1d9fae100..7a1d5c517be57 100644
--- a/clang/test/CIR/CodeGen/thread-local-in-func.cpp
+++ b/clang/test/CIR/CodeGen/thread-local-in-func.cpp
@@ -39,8 +39,8 @@ void test_int(int param) {
thread_local int init = param + local + get_i();
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z8test_inti(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_CONST_TLS:.*]] = cir.get_global thread_local @_ZZ8test_intiE10const_init : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_TLS:.*]] = cir.get_global thread_local static_local @_ZZ8test_intiE4init : !cir.ptr<!s32i>
//
@@ -103,8 +103,8 @@ void test_ctor(int param) {
thread_local Ctor const_init = 5;
thread_local Ctor init = param + local + get_i();
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z9test_ctori(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_CONST_TLS:.*]] = cir.get_global thread_local static_local @_ZZ9test_ctoriE10const_init : !cir.ptr<!rec_Ctor>
//
// CIR-BEFORE-LPP: cir.local_init thread_local @_ZZ9test_ctoriE10const_init ctor {
@@ -193,8 +193,8 @@ void test_dtor(int param) {
int local;
thread_local Dtor const_init;
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z9test_dtori(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_TLS:.*]] = cir.get_global thread_local static_local @_ZZ9test_dtoriE10const_init : !cir.ptr<!rec_Dtor>
//
// CIR-BEFORE-LPP: cir.local_init thread_local @_ZZ9test_dtoriE10const_init dtor {
@@ -246,8 +246,8 @@ void test_ctordtor(int param) {
thread_local CtorDtor const_init = 5;
thread_local CtorDtor init = param + local + get_i();
// CIR-BOTH-LABEL: cir.func no_inline dso_local @_Z13test_ctordtori(
-// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR-BOTH: %[[PARAM_ALLOCA:.*]] = cir.alloca "param" {{.*}} init : !cir.ptr<!s32i>
+// CIR-BOTH: [[LOCAL_ALLOCA:.*]] = cir.alloca "local" {{.*}} : !cir.ptr<!s32i>
// CIR-BOTH: %[[GET_CONST_TLS:.*]] = cir.get_global thread_local static_local @_ZZ13test_ctordtoriE10const_init : !cir.ptr<!rec_CtorDtor>
// CIR-BEFORE-LLP: cir.local_init thread_local @_ZZ13test_ctordtoriE10const_init ctor {
// CIR-BEFORE-LPP: %[[GET_CONST_TLS_INIT:.*]] = cir.get_global thread_local static_local @_ZZ13test_ctordtoriE10const_init : !cir.ptr<!rec_CtorDtor>
diff --git a/clang/test/CIR/CodeGen/three-way-cmp.cpp b/clang/test/CIR/CodeGen/three-way-cmp.cpp
index 00926f940627c..f7f46d6e0361b 100644
--- a/clang/test/CIR/CodeGen/three-way-cmp.cpp
+++ b/clang/test/CIR/CodeGen/three-way-cmp.cpp
@@ -106,13 +106,13 @@ struct HasMember {
void use_pseudo_ordering(HasMember m1, HasMember m2) {
// BOTH: cir.func {{.*}}@_ZNK9HasMemberssERKS_(%{{.*}}: !cir.ptr<!rec_HasMember>{{.*}}, %{{.*}}: !cir.ptr<!rec_HasMember>{{.*}}) -> !rec_std3A3A__13A3Astrong_ordering
- // BOTH: %[[LHS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_HasMember> -> !cir.ptr<!cir.ptr<!rec_HasMember>>
- // BOTH: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const !cir.ptr<!rec_HasMember> -> !cir.ptr<!cir.ptr<!rec_HasMember>>
- // BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
+ // BOTH: %[[LHS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_HasMember>>
+ // BOTH: %[[RHS_ALLOCA:.*]] = cir.alloca "" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_HasMember>>
+ // BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: %[[LHS_LOAD:.*]] = cir.load deref %[[LHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMember>>, !cir.ptr<!rec_HasMember>
// BOTH: cir.scope {
- // BOTH: %[[CMP_RES:.*]] = cir.alloca "cmp" {{.*}} init !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
- // BOTH: %[[CMP_TEMP:.*]] = cir.alloca "agg.tmp0" {{.*}} !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
+ // BOTH: %[[CMP_RES:.*]] = cir.alloca "cmp" {{.*}} init : !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
+ // BOTH: %[[CMP_TEMP:.*]] = cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: %[[LHS_MEMBER:.*]] = cir.cast bitcast %[[LHS_LOAD]] : !cir.ptr<!rec_HasMember> -> !cir.ptr<!rec_Member>
// BOTH: %[[RHS_LOAD:.*]] = cir.load %[[RHS_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_HasMember>>, !cir.ptr<!rec_HasMember>
// BOTH: %[[RHS_MEMBER:.*]] = cir.cast bitcast %[[RHS_LOAD]] : !cir.ptr<!rec_HasMember> -> !cir.ptr<!rec_Member>
@@ -148,9 +148,9 @@ void use_pseudo_ordering(HasMember m1, HasMember m2) {
// BOTH: cir.return %[[RET_LOAD]] : !rec_std3A3A__13A3Astrong_ordering
// BOTH: cir.func {{.*}} @_Z19use_pseudo_ordering9HasMemberS_(%[[M1:.*]]: !rec_HasMember{{.*}}, %[[M2:.*]]: !rec_HasMember{{.*}})
- // BOTH: %[[M1_ALLOCA:.*]] = cir.alloca "m1" {{.*}} init !rec_HasMember -> !cir.ptr<!rec_HasMember>
- // BOTH: %[[M2_ALLOCA:.*]] = cir.alloca "m2" align(1) init !rec_HasMember -> !cir.ptr<!rec_HasMember>
- // BOTH: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init !rec_std3A3A__13A3Astrong_ordering -> !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
+ // BOTH: %[[M1_ALLOCA:.*]] = cir.alloca "m1" {{.*}} init : !cir.ptr<!rec_HasMember>
+ // BOTH: %[[M2_ALLOCA:.*]] = cir.alloca "m2" align(1) init : !cir.ptr<!rec_HasMember>
+ // BOTH: %[[G_ALLOCA:.*]] = cir.alloca "g" {{.*}} init : !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: %[[CALL_RES:.*]] = cir.call @_ZNK9HasMemberssERKS_(%[[M1_ALLOCA]], %[[M2_ALLOCA]]) : (!cir.ptr<!rec_HasMember> {{.*}}, !cir.ptr<!rec_HasMember> {{.*}}) -> !rec_std3A3A__13A3Astrong_ordering
// BOTH: cir.store {{.*}}%[[CALL_RES]], %[[G_ALLOCA]] : !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
std::strong_ordering g = (m1 <=> m2);
diff --git a/clang/test/CIR/CodeGen/throws.cpp b/clang/test/CIR/CodeGen/throws.cpp
index cafbbe6527ca9..38e23ccab67d8 100644
--- a/clang/test/CIR/CodeGen/throws.cpp
+++ b/clang/test/CIR/CodeGen/throws.cpp
@@ -24,9 +24,9 @@ int rethrow_from_block(int a, int b) {
return a / b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.store %{{.*}}, %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
@@ -149,7 +149,7 @@ void throw_vector_type() {
throw a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 16 -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[EXCEPTION_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -175,7 +175,7 @@ void throw_ext_vector_type() {
throw a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 16 -> !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[EXCEPTION_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -249,7 +249,7 @@ void throw_pointer_type() {
throw ptr;
}
-// CIR: %[[PTR_ADDR:.*]] = cir.alloca "ptr" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[PTR_ADDR:.*]] = cir.alloca "ptr" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[VAR_ADDR:.*]] = cir.get_global @_ZZ18throw_pointer_typevE3var : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[VAR_ADDR]], %[[PTR_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[EXCEPTION_ADDR:.*]] = cir.alloc.exception 8 -> !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGen/thunks.cpp b/clang/test/CIR/CodeGen/thunks.cpp
index dfdc1225cc020..e089cc376775b 100644
--- a/clang/test/CIR/CodeGen/thunks.cpp
+++ b/clang/test/CIR/CodeGen/thunks.cpp
@@ -252,7 +252,7 @@ void C::f(int x, ...) {}
// CIR: cir.func {{.*}} @_ZThn8_N5Test51C1hEv(%arg0: !cir.ptr<
// CIR: %[[T5_THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init
-// CIR: %[[T5_RETVAL:.*]] = cir.alloca "__retval" {{.*}} !rec_Test5{{.*}}NonTrivial
+// CIR: %[[T5_RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Test53A3ANonTrivial>
// CIR: cir.store %arg0, %[[T5_THIS_ADDR]]
// CIR: %[[T5_THIS:.*]] = cir.load %[[T5_THIS_ADDR]]
// CIR: %[[T5_CAST:.*]] = cir.cast bitcast %[[T5_THIS]] : !cir.ptr<{{.*}}> -> !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp b/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp
index eef02a3f8fe1a..a1da635981f33 100644
--- a/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp
+++ b/clang/test/CIR/CodeGen/trivial-ctor-const-init.cpp
@@ -27,7 +27,7 @@ StructWithCtorArg withArg = 0.0;
// OGCG: @withArg = global %struct.StructWithCtorArg zeroinitializer
// CIR: cir.func {{.*}} @__cxx_global_var_init()
-// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} !cir.double -> !cir.ptr<!cir.double>
+// CIR: %[[TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!cir.double>
// CIR: %[[WITH_ARG:.*]] = cir.get_global @withArg : !cir.ptr<!rec_StructWithCtorArg>
// CIR: %[[ZERO:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.double
// CIR: cir.store{{.*}} %[[ZERO]], %[[TMP0]] : !cir.double, !cir.ptr<!cir.double>
diff --git a/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp b/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp
index ac0f35c8eb42e..e308d22256063 100644
--- a/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/try-catch-all-with-cleanup.cpp
@@ -24,7 +24,7 @@ void test_catch_all_with_cleanup() {
// CIR-LABEL: cir.func {{.*}} @_Z27test_catch_all_with_cleanupv()
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
// CIR: cir.try {
// CIR: cir.call @_ZN1SC1Ev(%[[S]])
// CIR: cir.cleanup.scope {
@@ -49,7 +49,7 @@ void test_catch_all_with_cleanup() {
// CIR-FLAT-LABEL: cir.func {{.*}} @_Z27test_catch_all_with_cleanupv()
//
-// CIR-FLAT: %[[S:.*]] = cir.alloca {{.*}} !rec_S
+// CIR-FLAT: %[[S:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_S>
//
// Ctor may throw; unwinds directly to the dispatch (no cleanup needed yet).
// CIR-FLAT: cir.try_call @_ZN1SC1Ev(%[[S]]) ^[[AFTER_CTOR:bb[0-9]+]], ^[[CTOR_UNWIND:bb[0-9]+]]
@@ -148,8 +148,8 @@ void test_catch_all_and_specific_with_cleanup() {
// CIR-LABEL: cir.func {{.*}} @_Z40test_catch_all_and_specific_with_cleanupv()
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init !rec_S -> !cir.ptr<!rec_S>
-// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} init : !cir.ptr<!rec_S>
+// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: cir.call @_ZN1SC1Ev(%[[S]])
// CIR: cir.cleanup.scope {
@@ -184,7 +184,7 @@ void test_catch_all_and_specific_with_cleanup() {
// CIR-FLAT-LABEL: cir.func {{.*}} @_Z40test_catch_all_and_specific_with_cleanupv()
//
-// CIR-FLAT: %[[S:.*]] = cir.alloca {{.*}} !rec_S
+// CIR-FLAT: %[[S:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_S>
//
// Ctor may throw; unwinds directly to the dispatch (no cleanup needed yet).
// CIR-FLAT: cir.try_call @_ZN1SC1Ev(%[[S]]) ^[[AFTER_CTOR:bb[0-9]+]], ^[[CTOR_UNWIND:bb[0-9]+]]
diff --git a/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp b/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp
index faa6f803fbec2..9e3f627acbea1 100644
--- a/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp
+++ b/clang/test/CIR/CodeGen/try-catch-non-trivial-copy.cpp
@@ -42,10 +42,10 @@ int test_non_trivial_exception_copy() {
// it later.
// CIR-LABEL: cir.func {{.*}} @_Z31test_non_trivial_exception_copyv()
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RV:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[RV:.*]] = cir.alloca "rv" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} !rec_MyException -> !cir.ptr<!rec_MyException>
+// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} : !cir.ptr<!rec_MyException>
// CIR: cir.try {
// CIR: cir.call @_Z8mayThrowv() : () -> ()
// CIR: } catch [type #cir.global_view<@_ZTI11MyException> : !cir.ptr<!u8i>] (%[[EH_TOKEN:.*]]: !cir.eh_token {{.*}}) {
@@ -357,7 +357,7 @@ int test_copy_ctor_extra_args() {
// exact switch shape here, but we do verify the EH-relevant control flow.
// CIR-FLAT-LABEL: cir.func {{.*}} @_Z25test_copy_ctor_extra_argsv()
-// CIR-FLAT: %{{.*}} = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+// CIR-FLAT: %{{.*}} = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
// CIR-FLAT: cir.try_call @_Z8mayThrowv() ^[[T2F_CONT:bb[0-9]+]], ^[[T2F_LPAD:bb[0-9]+]]
// CIR-FLAT: ^[[T2F_LPAD]]:
diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp
index 674a2c8aa3544..3776f4a1292c6 100644
--- a/clang/test/CIR/CodeGen/try-catch.cpp
+++ b/clang/test/CIR/CodeGen/try-catch.cpp
@@ -40,7 +40,7 @@ void try_catch_with_empty_catch_all() {
}
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i
// CIR: cir.scope {
@@ -84,7 +84,7 @@ void try_catch_with_empty_catch_all_2() {
}
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store{{.*}} %[[CONST_1]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.scope {
@@ -129,9 +129,9 @@ void try_catch_with_alloca() {
// CIR: cir.func {{.*}} @_Z21try_catch_with_allocav() personality(@__gxx_personality_v0)
// CIR: cir.scope {
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!s32i>, !s32i
@@ -886,7 +886,7 @@ void cleanup_inside_try_body() {
// CIR: cir.func {{.*}} @_Z23cleanup_inside_try_bodyv(){{.*}} personality(@__gxx_personality_v0){{.*}} {
// CIR: cir.scope {
-// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} !rec_S -> !cir.ptr<!rec_S>
+// CIR: %[[S:.*]] = cir.alloca "s" {{.*}} : !cir.ptr<!rec_S>
// CIR: cir.try {
// CIR: cir.cleanup.scope {
// CIR: cir.call @_Z8divisionv()
@@ -1113,7 +1113,7 @@ void call_function_inside_try_catch_with_ref_ptr_of_record_exception_type() {
}
// CIR: cir.func {{.*}} @_Z68call_function_inside_try_catch_with_ref_ptr_of_record_exception_typev(){{.*}} personality(@__gxx_personality_v0){{.*}} {
-// CIR: %[[E_ADDR:.*]] = cir.alloca "ref_ptr" {{.*}} const !cir.ptr<!cir.ptr<!rec_Record>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_Record>>>
+// CIR: %[[E_ADDR:.*]] = cir.alloca "ref_ptr" {{.*}} const : !cir.ptr<!cir.ptr<!cir.ptr<!rec_Record>>>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1345,10 +1345,10 @@ int init_catch_param_with_type_int() {
}
// CIR: cir.func {{.*}} @_Z30init_catch_param_with_type_intv() {{.*}} personality(@__gxx_personality_v0)
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1486,10 +1486,10 @@ int init_catch_param_with_type_int_ptr() {
}
// CIR: cir.func {{.*}} @_Z34init_catch_param_with_type_int_ptrv() {{.*}} personality(@__gxx_personality_v0)
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1627,10 +1627,10 @@ int init_catch_param_with_ref_to_ptr_to_non_record() {
}
// CIR: cir.func {{.*}} @_Z46init_catch_param_with_ref_to_ptr_to_non_recordv() {{.*}} personality(@__gxx_personality_v0)
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[RV_ADDR:.*]] = cir.alloca "rv" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.scope {
-// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} const !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} const : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CIR: cir.try {
// CIR: %[[CALL:.*]] = cir.call @_Z8divisionv() : () -> (!s32i {llvm.noundef})
// CIR: cir.yield
@@ -1772,7 +1772,7 @@ void direct_inside_try_catch_with_exception_type() {
// CIR: cir.func {{.*}} @_Z43direct_inside_try_catch_with_exception_typev() personality(@__gxx_personality_v0)
// CIR: cir.scope {
-// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[E:.*]] = cir.alloca "e" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.try {
// CIR: %[[EXN:.*]] = cir.alloc.exception 4 -> !cir.ptr<!s32i>
// CIR: %[[FORTYTWO:.*]] = cir.const #cir.int<42> : !s32i
diff --git a/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp b/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp
index 91b5c36d556bd..db44c2a4e483c 100644
--- a/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp
+++ b/clang/test/CIR/CodeGen/try-no-throwing-calls.cpp
@@ -24,7 +24,7 @@ int test() {
// Verify the try body (call + store) is preserved, not discarded.
// CIR: cir.func {{.*}} @_Z4testv
-// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RESULT:.*]] = cir.alloca "result" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[CALL:.*]] = cir.call @_Z11nonThrowingv()
// CIR: cir.store {{.*}}%[[CALL]], %[[RESULT]]
diff --git a/clang/test/CIR/CodeGen/typedef.c b/clang/test/CIR/CodeGen/typedef.c
index d85fc24a192e9..a4254c1c2ba75 100644
--- a/clang/test/CIR/CodeGen/typedef.c
+++ b/clang/test/CIR/CodeGen/typedef.c
@@ -11,7 +11,7 @@ void local_typedef(void) {
}
// CIR: cir.func{{.*}} @local_typedef()
-// CIR: cir.alloca "s" align(4) !rec_Struct -> !cir.ptr<!rec_Struct>
+// CIR: cir.alloca "s" align(4) : !cir.ptr<!rec_Struct>
// CIR: cir.return
// LLVM: %struct.Struct = type { i32 }
diff --git a/clang/test/CIR/CodeGen/unary.cpp b/clang/test/CIR/CodeGen/unary.cpp
index 52652cd950d06..87e06aa0baa38 100644
--- a/clang/test/CIR/CodeGen/unary.cpp
+++ b/clang/test/CIR/CodeGen/unary.cpp
@@ -11,7 +11,7 @@ unsigned up0() {
}
// CHECK: cir.func{{.*}} @_Z3up0v() -> (!u32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// LLVM: define{{.*}} i32 @_Z3up0v()
@@ -31,7 +31,7 @@ unsigned um0() {
}
// CHECK: cir.func{{.*}} @_Z3um0v() -> (!u32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// CHECK: %[[OUTPUT:.*]] = cir.minus %[[INPUT]]
@@ -54,7 +54,7 @@ unsigned un0() {
}
// CHECK: cir.func{{.*}} @_Z3un0v() -> (!u32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u32i>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// CHECK: %[[OUTPUT:.*]] = cir.not %[[INPUT]]
@@ -78,7 +78,7 @@ int inc0() {
}
// CHECK: cir.func{{.*}} @_Z4inc0v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -106,7 +106,7 @@ int dec0() {
}
// CHECK: cir.func{{.*}} @_Z4dec0v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -134,7 +134,7 @@ int inc1() {
}
// CHECK: cir.func{{.*}} @_Z4inc1v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -162,7 +162,7 @@ int dec1() {
}
// CHECK: cir.func{{.*}} @_Z4dec1v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -191,8 +191,8 @@ int inc2() {
}
// CHECK: cir.func{{.*}} @_Z4inc2v() -> (!s32i{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[ATMP:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !s32i
// CHECK: %[[ATOB:.*]] = cir.load{{.*}} %[[A]]
@@ -228,7 +228,7 @@ float fpPlus() {
}
// CHECK: cir.func{{.*}} @_Z6fpPlusv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// LLVM: define{{.*}} float @_Z6fpPlusv()
@@ -248,7 +248,7 @@ float fpMinus() {
}
// CHECK: cir.func{{.*}} @_Z7fpMinusv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
// CHECK: %[[OUTPUT:.*]] = cir.minus %[[INPUT]]
@@ -271,7 +271,7 @@ float fpPreInc() {
}
// CHECK: cir.func{{.*}} @_Z8fpPreIncv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -296,7 +296,7 @@ float fpPreDec() {
}
// CHECK: cir.func{{.*}} @_Z8fpPreDecv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -321,7 +321,7 @@ float fpPostInc() {
}
// CHECK: cir.func{{.*}} @_Z9fpPostIncv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -346,7 +346,7 @@ float fpPostDec() {
}
// CHECK: cir.func{{.*}} @_Z9fpPostDecv() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[INPUT:.*]] = cir.load{{.*}} %[[A]]
@@ -373,8 +373,8 @@ float fpPostInc2() {
}
// CHECK: cir.func{{.*}} @_Z10fpPostInc2v() -> (!cir.float{{.*}})
-// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
-// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %[[A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.float>
+// CHECK: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.float>
// CHECK: %[[ATMP:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CHECK: cir.store{{.*}} %[[ATMP]], %[[A]] : !cir.float
// CHECK: %[[ATOB:.*]] = cir.load{{.*}} %[[A]]
@@ -559,8 +559,8 @@ void f16NestedUPlus() {
}
// CHECK: cir.func{{.*}} @_Z14f16NestedUPlusv()
-// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
-// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.f16>
+// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.f16>
// CHECK: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CHECK: %[[A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
// CHECK: %[[RESULT:.*]] = cir.cast floating %[[A_F32]] : !cir.float -> !cir.f16
@@ -588,8 +588,8 @@ void f16NestedUMinus() {
}
// CHECK: cir.func{{.*}} @_Z15f16NestedUMinusv()
-// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.f16 -> !cir.ptr<!cir.f16>
-// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.f16 -> !cir.ptr<!cir.f16>
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.f16>
+// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.f16>
// CHECK: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
// CHECK: %[[A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
// CHECK: %[[A_MINUS:.*]] = cir.minus %[[A_F32]] : !cir.float
diff --git a/clang/test/CIR/CodeGen/union-agg-init.c b/clang/test/CIR/CodeGen/union-agg-init.c
index 8b4523a8d9877..ccf61d55b1226 100644
--- a/clang/test/CIR/CodeGen/union-agg-init.c
+++ b/clang/test/CIR/CodeGen/union-agg-init.c
@@ -15,7 +15,7 @@ typedef union vec3 {
// In C mode, this does do zero padding.
vec3 ret_vec3() {
// CIR-LABEL: ret_vec3
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_vec3 -> !cir.ptr<!rec_vec3>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_vec3>
// CIR: %[[GET_ANON:.*]] = cir.get_member %[[RET_ALLOCA]][0] {name = ""}
// CIR: %[[GET_X:.*]] = cir.get_member %[[GET_ANON]][0] {name = "x"}
// CIR: %[[FIVE:.*]] = cir.const #cir.fp<5.{{.*}}> : !cir.double
@@ -53,7 +53,7 @@ struct outer ret_outer() {
return o;
// CIR-LABEL: ret_outer
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} init !rec_outer -> !cir.ptr<!rec_outer>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} init : !cir.ptr<!rec_outer>
// CIR: %[[BITCAST:.*]] = cir.cast bitcast %0 : !cir.ptr<!rec_outer> -> !cir.ptr<!{{.*}}>
// CIR: %[[RECORD:.*]] = cir.const #cir.const_record<{#cir.zero : !{{.*}}, #cir.int<1> : !s32i, #cir.const_array<[#cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i, #cir.zero : !u8i]> : !cir.array<!u8i x 4>}>
// CIR: cir.store {{.*}}%[[RECORD]], %[[BITCAST]]
diff --git a/clang/test/CIR/CodeGen/union-agg-init.cpp b/clang/test/CIR/CodeGen/union-agg-init.cpp
index 0a9219859dab6..7414ece17e765 100644
--- a/clang/test/CIR/CodeGen/union-agg-init.cpp
+++ b/clang/test/CIR/CodeGen/union-agg-init.cpp
@@ -13,7 +13,7 @@ typedef union vec3 {
// In C++ mode, this doesn't do zero padding.
extern "C" vec3 ret_vec3() {
// CIR-LABEL: ret_vec3
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_vec3 -> !cir.ptr<!rec_vec3>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_vec3>
// CIR: %[[GET_ANON:.*]] = cir.get_member %[[RET_ALLOCA]][0] {name = ""}
// CIR: %[[GET_X:.*]] = cir.get_member %[[GET_ANON]][0] {name = "x"}
// CIR: %[[FIVE:.*]] = cir.const #cir.fp<5.{{.*}}> : !cir.double
@@ -43,7 +43,7 @@ typedef union Trivial {
extern "C" Trivial ret_trivial() { return {}; }
// CIR-LABEL: ret_trivial
- // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} !rec_Trivial -> !cir.ptr<!rec_Trivial>
+ // CIR: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Trivial>
// CIR: %[[GET_A:.*]] = cir.get_member %[[RET_ALLOCA]][0] {name = "a"}
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0>
// CIR: cir.store{{.*}} %[[ZERO]], %[[GET_A]]
diff --git a/clang/test/CIR/CodeGen/union.c b/clang/test/CIR/CodeGen/union.c
index d6057b696b400..28bd9081ca17a 100644
--- a/clang/test/CIR/CodeGen/union.c
+++ b/clang/test/CIR/CodeGen/union.c
@@ -55,7 +55,7 @@ void f1(void) {
}
// CIR: cir.func{{.*}} @f1()
-// CIR-NEXT: cir.alloca "p" {{.*}} !cir.ptr<!rec_IncompleteU> -> !cir.ptr<!cir.ptr<!rec_IncompleteU>>
+// CIR-NEXT: cir.alloca "p" {{.*}} : !cir.ptr<!cir.ptr<!rec_IncompleteU>>
// CIR-NEXT: cir.return
// LLVM: define{{.*}} void @f1()
@@ -74,8 +74,8 @@ int f2(void) {
}
// CIR: cir.func{{.*}} @f2() -> !s32i
-// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
-// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) !rec_U1 -> !cir.ptr<!rec_U1>
+// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) : !cir.ptr<!rec_U1>
// CIR-NEXT: %[[I:.*]] = cir.const #cir.int<42> : !s32i
// CIR-NEXT: %[[N:.*]] = cir.get_member %[[U]][0] {name = "n"} : !cir.ptr<!rec_U1> -> !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} %[[I]], %[[N]] : !s32i, !cir.ptr<!s32i>
@@ -113,7 +113,7 @@ void shouldGenerateUnionAccess(union U2 u) {
}
// CIR: cir.func{{.*}} @shouldGenerateUnionAccess(%[[ARG:.*]]: !rec_U2
-// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(8) init !rec_U2 -> !cir.ptr<!rec_U2>
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(8) init : !cir.ptr<!rec_U2>
// CIR-NEXT: cir.store{{.*}} %[[ARG]], %[[U]] : !rec_U2, !cir.ptr<!rec_U2>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s8i
// CIR-NEXT: %[[B_PTR:.*]] = cir.get_member %[[U]][0] {name = "b"} : !cir.ptr<!rec_U2> -> !cir.ptr<!s8i>
@@ -170,7 +170,7 @@ void f3(union U3 u) {
}
// CIR: cir.func{{.*}} @f3(%[[ARG:.*]]: !rec_U3
-// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(1) init !rec_U3 -> !cir.ptr<!rec_U3>
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(1) init : !cir.ptr<!rec_U3>
// CIR-NEXT: cir.store{{.*}} %[[ARG]], %[[U]] : !rec_U3, !cir.ptr<!rec_U3>
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s8i
// CIR-NEXT: %[[IDX:.*]] = cir.const #cir.int<2> : !s64i
@@ -199,7 +199,7 @@ void f5(union U4 u) {
}
// CIR: cir.func{{.*}} @f5(%[[ARG:.*]]: !rec_U4
-// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init !rec_U4 -> !cir.ptr<!rec_U4>
+// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init : !cir.ptr<!rec_U4>
// CIR-NEXT: cir.store{{.*}} %[[ARG]], %[[U]] : !rec_U4, !cir.ptr<!rec_U4>
// CIR-NEXT: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
// CIR-NEXT: %[[IDX:.*]] = cir.const #cir.int<4> : !s64i
diff --git a/clang/test/CIR/CodeGen/var-arg-aggregate.c b/clang/test/CIR/CodeGen/var-arg-aggregate.c
index 10a2337900d51..d526b247404ef 100644
--- a/clang/test/CIR/CodeGen/var-arg-aggregate.c
+++ b/clang/test/CIR/CodeGen/var-arg-aggregate.c
@@ -20,9 +20,9 @@ struct Bar varargs_aggregate(int count, ...) {
}
// CIR-LABEL: cir.func {{.*}} @varargs_aggregate(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} init !rec_Bar -> !cir.ptr<!rec_Bar>
-// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
-// CIR: %[[TMP_ADDR:.+]] = cir.alloca "vaarg.tmp" {{.*}} !rec_Bar -> !cir.ptr<!rec_Bar>
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} init : !cir.ptr<!rec_Bar>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[TMP_ADDR:.+]] = cir.alloca "vaarg.tmp" {{.*}} : !cir.ptr<!rec_Bar>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
diff --git a/clang/test/CIR/CodeGen/var_arg.c b/clang/test/CIR/CodeGen/var_arg.c
index 64f0464d93e13..7204cef68578b 100644
--- a/clang/test/CIR/CodeGen/var_arg.c
+++ b/clang/test/CIR/CodeGen/var_arg.c
@@ -18,9 +18,9 @@ int varargs(int count, ...) {
}
// CIR-LABEL: cir.func {{.*}} @varargs(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
-// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
@@ -91,9 +91,9 @@ int stdarg_start(int count, ...) {
}
// CIR-LABEL: cir.func {{.*}} @stdarg_start(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
-// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
@@ -189,9 +189,9 @@ int varargs_new(char *fmt, ...) {
}
// CIR-LABEL: cir.func {{.*}} @varargs_new(
-// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} !cir.array<!rec___va_list_tag x 1> -> !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
-// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[VAAREA:.+]] = cir.alloca "args" {{.*}} : !cir.ptr<!cir.array<!rec___va_list_tag x 1>>
+// CIR: %[[RES_ADDR:.+]] = cir.alloca "res" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VA_PTR0:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
// CIR: cir.va_start %[[VA_PTR0]] : !cir.ptr<!rec___va_list_tag>
// CIR: %[[VA_PTR1:.+]] = cir.cast array_to_ptrdecay %[[VAAREA]] : !cir.ptr<!cir.array<!rec___va_list_tag x 1>> -> !cir.ptr<!rec___va_list_tag>
diff --git a/clang/test/CIR/CodeGen/variable-decomposition.cpp b/clang/test/CIR/CodeGen/variable-decomposition.cpp
index 4619167fff1f0..6ad818d6c6570 100644
--- a/clang/test/CIR/CodeGen/variable-decomposition.cpp
+++ b/clang/test/CIR/CodeGen/variable-decomposition.cpp
@@ -20,8 +20,8 @@ float function() {
// LLVM-DAG: @[[FUNC_CONST:.*]] = private constant %struct.some_struct { i32 1, float 2.000000e+00 }
// CIR-LABEL: cir.func {{.*}} @_Z8functionv() -> (!cir.float {llvm.noundef})
-// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} !cir.float -> !cir.ptr<!cir.float>
-// CIR: %[[STRUCT:.+]] = cir.alloca "" {{.*}} init !rec_some_struct -> !cir.ptr<!rec_some_struct>
+// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.float>
+// CIR: %[[STRUCT:.+]] = cir.alloca "" {{.*}} init : !cir.ptr<!rec_some_struct>
// CIR: %[[CONST:.+]] = cir.get_global @[[FUNC_CONST]] : !cir.ptr<!rec_some_struct>
// CIR: cir.copy %[[CONST]] to %[[STRUCT]]
// CIR: %[[MEMBER_A:.+]] = cir.get_member %[[STRUCT]][0] {name = "a"} : !cir.ptr<!rec_some_struct> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/vbase.cpp b/clang/test/CIR/CodeGen/vbase.cpp
index 27f711179ed3b..26dffcac6fa0a 100644
--- a/clang/test/CIR/CodeGen/vbase.cpp
+++ b/clang/test/CIR/CodeGen/vbase.cpp
@@ -57,7 +57,7 @@ void ppp() { B b; }
// OGCG: @_ZTV1B = linkonce_odr constant { [3 x ptr] } { [3 x ptr] [ptr inttoptr (i64 12 to ptr), ptr null, ptr @_ZTI1B] }, comdat, align 8
// CIR: cir.func {{.*}}@_Z1fv()
-// CIR: %[[D:.+]] = cir.alloca "d" {{.*}} init !rec_Derived -> !cir.ptr<!rec_Derived>
+// CIR: %[[D:.+]] = cir.alloca "d" {{.*}} init : !cir.ptr<!rec_Derived>
// CIR: cir.call @_ZN7DerivedC1Ev(%[[D]]) nothrow : (!cir.ptr<!rec_Derived> {{.*}}) -> ()
// CIR: %[[VPTR_PTR:.+]] = cir.vtable.get_vptr %[[D]] : !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.vptr>
// CIR: %[[VPTR:.+]] = cir.load {{.*}} %[[VPTR_PTR]] : !cir.ptr<!cir.vptr>, !cir.vptr
@@ -74,7 +74,7 @@ void ppp() { B b; }
// CIR: cir.return
// CIR: cir.func {{.*}}@_Z1gv()
-// CIR: %[[DF:.+]] = cir.alloca "df" {{.*}} init !rec_DerivedFinal -> !cir.ptr<!rec_DerivedFinal>
+// CIR: %[[DF:.+]] = cir.alloca "df" {{.*}} init : !cir.ptr<!rec_DerivedFinal>
// CIR: cir.call @_ZN12DerivedFinalC1Ev(%[[DF]]) nothrow : (!cir.ptr<!rec_DerivedFinal> {{.*}}) -> ()
// CIR: %[[BASE_THIS_2:.+]] = cir.base_class_addr %[[DF]] : !cir.ptr<!rec_DerivedFinal> nonnull [0] -> !cir.ptr<!rec_Base>
// CIR: cir.call @_ZN4Base1fEv(%[[BASE_THIS_2]]) : (!cir.ptr<!rec_Base> {{.*}}) -> ()
@@ -114,7 +114,7 @@ void ppp() { B b; }
// Constructor for B
// CIR: cir.func {{.*}} @_ZN1BC1Ev(%arg0: !cir.ptr<!rec_B>
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_B> -> !cir.ptr<!cir.ptr<!rec_B>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_B>>
// CIR: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
// CIR: %[[BASE_A_ADDR:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_B> nonnull [12] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/CodeGen/vector-ext-element.cpp b/clang/test/CIR/CodeGen/vector-ext-element.cpp
index 340d31fdd6f0a..ef9e177409a69 100644
--- a/clang/test/CIR/CodeGen/vector-ext-element.cpp
+++ b/clang/test/CIR/CodeGen/vector-ext-element.cpp
@@ -14,9 +14,9 @@ void element_expr_from_gl() {
int y = a.y;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[ELEM_0:.*]] = cir.vec.extract %[[TMP_A]][%[[CONST_0]] : !s64i] : !cir.vector<4 x !s32i>
@@ -52,9 +52,9 @@ void element_expr_from_gl_with_vec_result() {
vi4 c = a.wzyx;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s32i>
// CIR: %[[B_VALUE:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[POISON]] : !cir.vector<4 x !s32i>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i] : !cir.vector<2 x !s32i>
@@ -90,9 +90,9 @@ void element_expr_from_pointer() {
int Y = a->y;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.ptr<!cir.vector<4 x !s32i>> -> !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>
-// CIR: %[[X_ADDR:.*]] = cir.alloca "X" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[Y_ADDR:.*]] = cir.alloca "Y" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "X" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[Y_ADDR:.*]] = cir.alloca "Y" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TMP_A_PTR:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[TMP_A_PTR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
@@ -134,9 +134,9 @@ void element_expr_from_pointer_with_vec_result() {
vi4 c = a->wzyx;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.ptr<!cir.vector<4 x !s32i>> -> !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A_PTR:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!cir.vector<4 x !s32i>>>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[TMP_A_PTR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s32i>
@@ -179,12 +179,12 @@ void element_expr_from_rvalue() {
int y = (a + b).y;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[Y_ADDR:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[ADD_A_B:.*]] = cir.add %[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>
@@ -251,12 +251,12 @@ void element_expr_from_rvalue_with_vec_result() {
vi4 d = (a + b).wzyx;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
-// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca "tmp" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[TMP_1_ADDR:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[TMP_2_ADDR:.*]] = cir.alloca "tmp" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[ADD_A_B:.*]] = cir.add %[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>
@@ -321,7 +321,7 @@ void array_subscript_expr_with_element_expr_base() {
a.xyz[1] = 2;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i
// CIR: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s64i
// CIR: %[[A_PTR:.*]] = cir.cast bitcast %0 : !cir.ptr<!cir.vector<4 x !s32i>> -> !cir.ptr<!s32i>
@@ -346,8 +346,8 @@ void store_src_dest_same_size() {
b.xy = a.xy;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<2 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s32i>
// CIR: %[[SHUFFLE_A:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[POISON]] : !cir.vector<4 x !s32i>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i] : !cir.vector<2 x !s32i>
@@ -378,8 +378,8 @@ void store_src_dest_not_same_size() {
a.lo = b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<2 x !s32i>>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<2 x !s32i>>, !cir.vector<2 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<2 x !s32i>
@@ -408,8 +408,8 @@ void non_simple_base() {
int b = a.xy.x;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !s64i
// CIR: %[[RESULT:.*]] = cir.vec.extract %[[TMP_A]][%[[CONST_0]] : !s64i] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/CodeGen/vector-ext.cpp b/clang/test/CIR/CodeGen/vector-ext.cpp
index 607b047604619..4febc005a31c0 100644
--- a/clang/test/CIR/CodeGen/vector-ext.cpp
+++ b/clang/test/CIR/CodeGen/vector-ext.cpp
@@ -70,14 +70,14 @@ void foo() {
vi4 h = {};
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<3 x !s32i> -> !cir.ptr<!cir.vector<3 x !s32i>>
-// CIR: %[[VEC_C:.*]] = cir.alloca "c" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
-// CIR: %[[VEC_D:.*]] = cir.alloca "d" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
-// CIR: %[[VEC_E:.*]] = cir.alloca "e" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_F:.*]] = cir.alloca "f" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_G:.*]] = cir.alloca "g" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_H:.*]] = cir.alloca "h" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<3 x !s32i>>
+// CIR: %[[VEC_C:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.vector<2 x !s32i>>
+// CIR: %[[VEC_D:.*]] = cir.alloca "d" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[VEC_E:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_G:.*]] = cir.alloca "g" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_H:.*]] = cir.alloca "h" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_E_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_E_VAL]], %[[VEC_E]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -127,7 +127,7 @@ void foo() {
void foo2(vi4 p) {}
-// CIR: %[[VEC_A:.*]] = cir.alloca "p" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store{{.*}} %{{.*}}, %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// LLVM: %[[VEC_A:.*]] = alloca <4 x i32>, i64 1, align 16
@@ -141,8 +141,8 @@ void foo3() {
int e = a[1];
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -172,9 +172,9 @@ void foo4() {
int e = a[idx];
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -211,7 +211,7 @@ void foo5() {
a[2] = 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -240,9 +240,9 @@ void foo6() {
a[idx] = value;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[VAL:.*]] = cir.alloca "value" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[VAL:.*]] = cir.alloca "value" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -285,7 +285,7 @@ void foo7() {
a[2] += 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -324,10 +324,10 @@ void foo8() {
vi4 not_res = ~a;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[PLUS_RES:.*]] = cir.alloca "plus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[MINUS_RES:.*]] = cir.alloca "minus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[NOT_RES:.*]] = cir.alloca "not_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[PLUS_RES:.*]] = cir.alloca "plus_res" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[MINUS_RES:.*]] = cir.alloca "minus_res" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[NOT_RES:.*]] = cir.alloca "not_res" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -376,10 +376,10 @@ void foo9() {
vi4 shr = a >> b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -433,10 +433,10 @@ void foo10() {
uvi4 shr = b >> a;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
-// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -496,8 +496,8 @@ void foo11() {
vi4 j = a ^ b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -623,8 +623,8 @@ void foo12() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -738,8 +738,8 @@ void foo13() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !u32i, #cir.int<2> : !u32i,
// CIR-SAME: #cir.int<3> : !u32i, #cir.int<4> : !u32i]> : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>
@@ -853,8 +853,8 @@ void foo14() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float,
// CIR-SAME: #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
@@ -1045,7 +1045,7 @@ void foo17() {
vus2 W = __builtin_convertvector(a, vus2);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
// CIR: %[[RES:.*]] = cir.cast float_to_int %[[TMP]] : !cir.vector<2 x !cir.double> -> !cir.vector<2 x !u16i>
@@ -1065,10 +1065,10 @@ void foo18() {
uvi4 shr = b >> 3u;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
-// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CIR-SAME: #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1118,8 +1118,8 @@ void foo19() {
vi4 u = __builtin_shufflevector(a, b, 7, 5, 3, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<7> :
@@ -1143,8 +1143,8 @@ void foo20() {
vi4 u = __builtin_shufflevector(a, b, -1, 1, -1, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<-1> :
@@ -1167,7 +1167,7 @@ void foo21() {
unsigned long size = __builtin_vectorelements(a);
}
-// CIR: %[[INIT:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[INIT:.*]] = cir.alloca "size" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: cir.store align(8) %[[SIZE]], %[[INIT]] : !u64i, !cir.ptr<!u64i>
@@ -1183,9 +1183,9 @@ void logical_or_vi4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1223,9 +1223,9 @@ void logical_or_vf4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1263,9 +1263,9 @@ void foo24() {
vh4 c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.f16>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
// CIR: %[[TMP_A_F16:.*]] = cir.cast floating %[[TMP_A]] : !cir.vector<4 x !cir.f16> -> !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
@@ -1302,9 +1302,9 @@ void logical_and_vi4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1342,9 +1342,9 @@ void logical_and_vf4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1381,8 +1381,8 @@ void logical_not() {
vi4 b = !a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}}) %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
@@ -1407,8 +1407,8 @@ void unary_extension() {
vi4 b = __extension__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1429,10 +1429,10 @@ vi4 ternary_expression_with_vec_cond() {
return c ? a : b;
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_C:.*]] = cir.load {{.*}} %[[C_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/CodeGen/vector.cpp b/clang/test/CIR/CodeGen/vector.cpp
index d25ecea2d89f6..61f5e98295bfc 100644
--- a/clang/test/CIR/CodeGen/vector.cpp
+++ b/clang/test/CIR/CodeGen/vector.cpp
@@ -60,13 +60,13 @@ void foo() {
vi4 g = {};
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
-// CIR: %[[VEC_C:.*]] = cir.alloca "c" {{.*}} !cir.vector<2 x !s64i> -> !cir.ptr<!cir.vector<2 x !s64i>>
-// CIR: %[[VEC_D:.*]] = cir.alloca "d" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_E:.*]] = cir.alloca "e" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_F:.*]] = cir.alloca "f" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_G:.*]] = cir.alloca "g" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[VEC_C:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.vector<2 x !s64i>>
+// CIR: %[[VEC_D:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_E:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_G:.*]] = cir.alloca "g" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_D_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_D_VAL]], %[[VEC_D]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -114,7 +114,7 @@ void foo() {
void foo2(vi4 p) {}
-// CIR: %[[VEC_A:.*]] = cir.alloca "p" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store{{.*}} %{{.*}}, %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// LLVM: %[[VEC_A:.*]] = alloca <4 x i32>, i64 1, align 16
@@ -128,8 +128,8 @@ void foo3() {
int e = a[1];
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -159,9 +159,9 @@ void foo4() {
int e = a[idx];
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -198,7 +198,7 @@ void foo5() {
a[2] = 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -227,9 +227,9 @@ void foo6() {
a[idx] = value;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[VAL:.*]] = cir.alloca "value" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[IDX:.*]] = cir.alloca "idx" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[VAL:.*]] = cir.alloca "value" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -272,7 +272,7 @@ void foo7() {
a[2] += 5;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -311,10 +311,10 @@ void foo8() {
vi4 not_res = ~a;
}
-// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[PLUS_RES:.*]] = cir.alloca "plus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[MINUS_RES:.*]] = cir.alloca "minus_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[NOT_RES:.*]] = cir.alloca "not_res" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[PLUS_RES:.*]] = cir.alloca "plus_res" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[MINUS_RES:.*]] = cir.alloca "minus_res" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[NOT_RES:.*]] = cir.alloca "not_res" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_VAL]], %[[VEC]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -363,10 +363,10 @@ void foo9() {
vi4 shr = a >> b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -420,10 +420,10 @@ void foo10() {
uvi4 shr = b >> a;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
-// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -483,8 +483,8 @@ void foo11() {
vi4 j = a ^ b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -610,8 +610,8 @@ void foo12() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CIR-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -725,8 +725,8 @@ void foo13() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !u32i, #cir.int<2> : !u32i,
// CIR-SAME: #cir.int<3> : !u32i, #cir.int<4> : !u32i]> : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !u32i>, !cir.ptr<!cir.vector<4 x !u32i>>
@@ -840,8 +840,8 @@ void foo14() {
vi4 h = a >= b;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float,
// CIR-SAME: #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
@@ -1032,7 +1032,7 @@ void foo17() {
vus2 W = __builtin_convertvector(a, vus2);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
// CIR: %[[RES:.*]] = cir.cast float_to_int %[[TMP]] : !cir.vector<2 x !cir.double> -> !cir.vector<2 x !u16i>
@@ -1052,10 +1052,10 @@ void foo18() {
uvi4 shr = b >> 3u;
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
-// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init !cir.vector<4 x !u32i> -> !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[SHR_RES:.*]] = cir.alloca "shr" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CIR-SAME: #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1105,8 +1105,8 @@ void foo19() {
vi4 u = __builtin_shufflevector(a, b, 7, 5, 3, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<7> :
@@ -1185,8 +1185,8 @@ void foo23() {
vi4 u = __builtin_shufflevector(a, b, -1, 1, -1, 1);
}
-// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[SHUF:.*]] = cir.vec.shuffle(%[[TMP_A]], %[[TMP_B]] : !cir.vector<4 x !s32i>) [#cir.int<-1> :
@@ -1209,7 +1209,7 @@ void foo24() {
unsigned long size = __builtin_vectorelements(a);
}
-// CIR: %[[INIT:.*]] = cir.alloca "size" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[INIT:.*]] = cir.alloca "size" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: cir.store align(8) %[[SIZE]], %[[INIT]] : !u64i, !cir.ptr<!u64i>
@@ -1225,9 +1225,9 @@ void logical_or_vi4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1265,9 +1265,9 @@ void logical_or_vf4() {
vi4 c = a || b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1305,9 +1305,9 @@ void foo27() {
vh4 c = a + b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !cir.f16> -> !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.f16>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.f16>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
// CIR: %[[TMP_A_F16:.*]] = cir.cast floating %[[TMP_A]] : !cir.vector<4 x !cir.f16> -> !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.f16>>, !cir.vector<4 x !cir.f16>
@@ -1344,9 +1344,9 @@ void logical_and_vi4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
@@ -1384,9 +1384,9 @@ void logical_and_vf4() {
vi4 c = a && b;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -1423,8 +1423,8 @@ void logical_not() {
vi4 b = !a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}}) %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !s32i>
// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
@@ -1449,8 +1449,8 @@ void logical_not_float() {
vi4 b = !a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
// CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
@@ -1475,8 +1475,8 @@ void unary_extension() {
vi4 b = __extension__ a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -1497,10 +1497,10 @@ vi4 ternary_expression_with_vec_cond() {
return c ? a : b;
}
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[TMP_C:.*]] = cir.load {{.*}} %[[C_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp b/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp
index 51e0a1dc564b0..5a0cf6a2c7340 100644
--- a/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp
+++ b/clang/test/CIR/CodeGen/virtual-destructor-calls.cpp
@@ -135,7 +135,7 @@ class D {
D::~D() = default;
// CIR: cir.func{{.*}} @_ZN1DD2Ev
-// CIR: %[[THIS:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_D>>
// CIR: cir.store %[[ARG0:.*]], %[[THIS]] : !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[THIS1:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_D>>, !cir.ptr<!rec_D>
// CIR: cir.return
@@ -155,7 +155,7 @@ D::~D() = default;
// CIR: cir.func {{.*}} @_ZN1DD1Ev(!cir.ptr<!rec_D>) alias(@_ZN1DD2Ev)
// CIR: cir.func{{.*}} @_ZN1DD0Ev
-// CIR: %[[THIS:.*]] = cir.alloca "this" align(8) init !cir.ptr<!rec_D> -> !cir.ptr<!cir.ptr<!rec_D>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_D>>
// CIR: cir.store %[[ARG0:.*]], %[[THIS]] : !cir.ptr<!rec_D>, !cir.ptr<!cir.ptr<!rec_D>>
// CIR: %[[THIS1:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_D>>, !cir.ptr<!rec_D>
// CIR: cir.trap
diff --git a/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp b/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp
index a69145213ee98..0f1e6d2d566be 100644
--- a/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp
+++ b/clang/test/CIR/CodeGen/virtual-fn-calls-eh.cpp
@@ -18,7 +18,7 @@ void call_virtual_fn_in_cleanup_scope() {
}
// CIR: cir.func {{.*}} @_Z32call_virtual_fn_in_cleanup_scopev()
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_B>
// CIR: cir.call @_ZN1BC2Ev(%[[B]])
// CIR: cir.cleanup.scope {
// CIR: %[[C_LITERAL:.*]] = cir.const #cir.int<99> : !s8i
@@ -30,7 +30,7 @@ void call_virtual_fn_in_cleanup_scope() {
// CIR: }
// CIR-FLAT: cir.func {{.*}} @_Z32call_virtual_fn_in_cleanup_scopev()
-// CIR-FLAT: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
+// CIR-FLAT: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_B>
// CIR-FLAT: cir.call @_ZN1BC2Ev(%[[B]]) nothrow : (!cir.ptr<!rec_B> {{.*}}) -> ()
// CIR-FLAT: cir.br ^[[CLEANUP_SCOPE:bb[0-9]+]]
// CIR-FLAT: ^[[CLEANUP_SCOPE]]:
diff --git a/clang/test/CIR/CodeGen/virtual-function-calls.cpp b/clang/test/CIR/CodeGen/virtual-function-calls.cpp
index 4e1696703ad03..352b19c6babb6 100644
--- a/clang/test/CIR/CodeGen/virtual-function-calls.cpp
+++ b/clang/test/CIR/CodeGen/virtual-function-calls.cpp
@@ -23,7 +23,7 @@ A::A() {}
// OGCG: @_ZTV1A = external constant { [3 x ptr] }
// CIR: cir.func{{.*}} @_ZN1AC2Ev(%arg0: !cir.ptr<!rec_A> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_A> -> !cir.ptr<!cir.ptr<!rec_A>>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_A>>
// CIR: cir.store %arg0, %[[THIS_ADDR]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
// CIR: %[[VPTR:.*]] = cir.vtable.address_point(@_ZTV1A, address_point = <index = 0, offset = 2>) : !cir.vptr
@@ -52,7 +52,7 @@ void f1(A *a) {
}
// CIR: cir.func{{.*}} @_Z2f1P1A(%arg0: !cir.ptr<!rec_A> {{.*}})
-// CIR: %[[A_ADDR:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_A>
+// CIR: %[[A_ADDR:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!rec_A>>
// CIR: cir.store %arg0, %[[A_ADDR]]
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_ADDR]]
// CIR: %[[C_LITERAL:.*]] = cir.const #cir.int<99> : !s8i
@@ -91,7 +91,7 @@ void call_virtual_fn_in_cleanup_scope() {
}
// CIR: cir.func {{.*}} @_Z32call_virtual_fn_in_cleanup_scopev()
-// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init !rec_B -> !cir.ptr<!rec_B>
+// CIR: %[[B:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!rec_B>
// CIR: cir.call @_ZN1BC2Ev(%[[B]])
// CIR: cir.cleanup.scope {
// CIR: %[[C_LITERAL:.*]] = cir.const #cir.int<99> : !s8i
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index e61e114a195f4..cf288b68b3919 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -10,14 +10,14 @@ void f0(int len) {
}
// CIR: cir.func{{.*}} @f0(%[[LEN_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[LEN_SIZE_T]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} size(%[[LEN_SIZE_T]]) : !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
@@ -95,8 +95,8 @@ void f1(int len) {
}
// CIR: cir.func{{.*}} @f1(%[[LEN_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[SIXTEEN:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
@@ -104,7 +104,7 @@ void f1(int len) {
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
// CIR: %[[TOTAL_LEN:.*]] = cir.mul nuw %[[SIXTEEN]], %[[LEN_SIZE_T]]
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[TOTAL_LEN]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} size(%[[TOTAL_LEN]]) : !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
@@ -143,8 +143,8 @@ void f2(int len) {
}
// CIR: cir.func{{.*}} @f2(%[[LEN_ARG:.*]]: !s32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
@@ -152,7 +152,7 @@ void f2(int len) {
// CIR: %[[TOTAL_LEN_SIZE_T:.*]] = cir.cast integral %[[TOTAL_LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[TOTAL_LEN_SIZE_T]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} size(%[[TOTAL_LEN_SIZE_T]]) : !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
@@ -195,15 +195,15 @@ void f3(unsigned len) {
}
// CIR: cir.func{{.*}} @f3(%[[LEN_ARG:.*]]: !u32i {{.*}})
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !u32i -> !cir.ptr<!u32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
-// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!u32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[I:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!u32i>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !u32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[S1:.*]] = cir.alloca "s1" {{.*}} %[[LEN_SIZE_T]] : !u64i, !s8i -> !cir.ptr<!s8i>
+// CIR: %[[S1:.*]] = cir.alloca "s1" {{.*}} size(%[[LEN_SIZE_T]]) : !cir.ptr<!s8i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CIR: cir.store{{.*}} %[[ZERO]], %[[I]]
// CIR: cir.scope {
@@ -216,12 +216,12 @@ void f3(unsigned len) {
// CIR: cir.condition(%[[CMP]])
// CIR: } do {
// CIR: cir.scope {
-// CIR: %[[SAVED_STACK2:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[SAVED_STACK2:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[I_LEN:.*]] = cir.load{{.*}} %[[I]]
// CIR: %[[I_LEN_SIZE_T2:.*]] = cir.cast integral %[[I_LEN]] : !u32i -> !u64i
// CIR: %[[STACK_PTR2:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR2]], %[[SAVED_STACK2]]
-// CIR: %[[S2:.*]] = cir.alloca "s2" {{.*}} %[[I_LEN_SIZE_T2]] : !u64i, !s8i -> !cir.ptr<!s8i>
+// CIR: %[[S2:.*]] = cir.alloca "s2" {{.*}} size(%[[I_LEN_SIZE_T2]]) : !cir.ptr<!s8i>
// CIR: %[[SAVED_RESTORE_PTR2:.*]] = cir.load{{.*}} %[[SAVED_STACK2]]
// CIR: cir.stackrestore %[[SAVED_RESTORE_PTR2]]
// CIR: }
@@ -329,14 +329,14 @@ int f5(unsigned long len) {
}
// CIR: cir.func{{.*}} @f5(%[[LEN_ARG:.*]]: !u64i {{.*}}) -> !s32i
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store{{.*}} %[[LEN_ARG]], %[[LEN_ADDR]]
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} %[[LEN]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} size(%[[LEN]]) : !cir.ptr<!s32i>
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s64i
// CIR: %[[ARR_2:.*]] = cir.ptr_stride %[[ARR]], %[[TWO]]
// CIR: %[[ARR_VAL:.*]] = cir.load{{.*}} %[[ARR_2]] : !cir.ptr<!s32i>, !s32i
@@ -387,9 +387,9 @@ void vla_subscript_expr() {
(int (**)[n]){&a}[0][1][5] = 0;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[COMPOUND_ADDR:.*]] = cir.alloca ".compoundliteral" {{.*}} !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[COMPOUND_ADDR:.*]] = cir.alloca ".compoundliteral" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CIR: %[[CONST_5:.*]] = cir.const #cir.int<5> : !u64i
// CIR: cir.store {{.*}} %[[CONST_5]], %[[N_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_0_VAL:.*]] = cir.const #cir.int<0> : !s32i
@@ -440,10 +440,10 @@ double vla_param_2d(int n, double m[n][n], int i, int j) {
}
// CIR: cir.func{{.*}} @vla_param_2d(%[[N_ARG:.*]]: !s32i {{.*}}, %[[M_ARG:.*]]: !cir.ptr<!cir.double> {{.*}}, %[[I_ARG:.*]]: !s32i {{.*}}, %[[J_ARG:.*]]: !s32i {{.*}}) -> !cir.double
-// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init !cir.ptr<!cir.double> -> !cir.ptr<!cir.ptr<!cir.double>>
-// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[J_ADDR:.*]] = cir.alloca "j" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[N_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[M_ADDR:.*]] = cir.alloca "m" {{.*}} init : !cir.ptr<!cir.ptr<!cir.double>>
+// CIR: %[[I_ADDR:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[J_ADDR:.*]] = cir.alloca "j" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store{{.*}} %[[N_ARG]], %[[N_ADDR]]
// CIR: cir.store{{.*}} %[[M_ARG]], %[[M_ADDR]]
// CIR: cir.store{{.*}} %[[I_ARG]], %[[I_ADDR]]
@@ -512,15 +512,15 @@ void complex_vla_cast(int n) {
}
// CIR: cir.func {{.*}} @complex_vla_cast
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} !cir.ptr<!u8i> -> !cir.ptr<!cir.ptr<!u8i>>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store %{{.*}}, %[[LEN_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[LEN:.*]] = cir.load {{.*}} %[[LEN_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_PTR]], %[[SAVED_STACK]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ArR:.*]] = cir.alloca "arr" {{.*}} %3 : !u64i, !cir.complex<!cir.float> -> !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ArR:.*]] = cir.alloca "arr" {{.*}} size(%3) : !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.yield
// CIR: } cleanup normal {
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load {{.*}} %[[SAVED_STACK]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp
index 4f182f6b3c41c..0d2f7cee0e8b3 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-address-of.cpp
@@ -15,8 +15,8 @@ void builtin_address_of() {
Container* b = __builtin_addressof(a);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} !rec_Container -> !cir.ptr<!rec_Container>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.ptr<!rec_Container> -> !cir.ptr<!cir.ptr<!rec_Container>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!rec_Container>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Container>>
// CIR: cir.store {{.*}} %[[A_ADDR]], %[[B_ADDR]] : !cir.ptr<!rec_Container>, !cir.ptr<!cir.ptr<!rec_Container>>
// LLVM: %[[A_ADDR:.*]] = alloca %struct.Container, i64 1, align 4
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp
index 21a6047e2ca71..aac3505d42cc2 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-bcopy.cpp
@@ -7,8 +7,8 @@
void foo(void) {
// CIR-LABEL: cir.func no_inline dso_local @_Z3foov()
- // CIR: %[[V0:.*]] = cir.alloca "f4" align(16) !cir.array<!cir.float x 4> -> !cir.ptr<!cir.array<!cir.float x 4>>
- // CIR: %[[V1:.*]] = cir.alloca "f8" align(16) !cir.array<!cir.float x 8> -> !cir.ptr<!cir.array<!cir.float x 8>>
+ // CIR: %[[V0:.*]] = cir.alloca "f4" align(16) : !cir.ptr<!cir.array<!cir.float x 4>>
+ // CIR: %[[V1:.*]] = cir.alloca "f8" align(16) : !cir.ptr<!cir.array<!cir.float x 8>>
// 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>
@@ -116,8 +116,8 @@ void testbcopy(const void *src, void *dest, size_t n) {
}
// CIR-LABEL: @testaddressof(
-// CIR: %[[SRC:.*]] = cir.alloca "src" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
-// CIR: %[[DEST:.*]] = cir.alloca "dest" {{.*}} init !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[SRC:.*]] = cir.alloca "src" {{.*}} init : !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[DEST:.*]] = cir.alloca "dest" {{.*}} init : !cir.ptr<!cir.ptr<!s8i>>
// CIR: %[[SRC_TO_VOIDPTR:.*]] = cir.cast bitcast %[[SRC]] : !cir.ptr<!cir.ptr<!s8i>> -> !cir.ptr<!void>
// CIR: %[[DEST_TO_VOIDPTR:.*]] = cir.cast bitcast %[[DEST]] : !cir.ptr<!cir.ptr<!s8i>> -> !cir.ptr<!void>
// CIR: cir.libc.memmove {{.*}} bytes from %[[SRC_TO_VOIDPTR]] to %[[DEST_TO_VOIDPTR]]
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp
index efda15add74ac..24eb7211551bf 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-bit-cast.cpp
@@ -118,7 +118,7 @@ two_ints test_rvalue_aggregate() {
}
// CIR-LABEL: cir.func {{.*}} @_Z21test_rvalue_aggregatev()
-// CIR: %[[#TMP_SLOT:]] = cir.alloca {{.*}} !u64i -> !cir.ptr<!u64i>
+// CIR: %[[#TMP_SLOT:]] = cir.alloca {{.*}} : !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>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp
index eca2327ec44c8..e93cba3a3c306 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-call.cpp
@@ -324,7 +324,7 @@ void *test_alloca(unsigned long n) {
}
// CIR-LABEL: @_Z11test_allocam(
-// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} %{{.+}} : !u64i, !u8i -> !cir.ptr<!u8i>
+// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} size(%{{.+}}) : !cir.ptr<!u8i>
// LLVM-LABEL: @_Z11test_allocam(
// LLVM: alloca i8, i64 %{{.+}}
@@ -339,8 +339,8 @@ bool test_multiple_allocas(unsigned long n) {
}
// CIR-LABEL: @_Z21test_multiple_allocasm(
-// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} %{{.+}} : !u64i, !u8i -> !cir.ptr<!u8i>
-// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} %{{.+}} : !u64i, !u8i -> !cir.ptr<!u8i>
+// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} size(%{{.+}}) : !cir.ptr<!u8i>
+// CIR: %{{.+}} = cir.alloca "bi_alloca" {{.*}} size(%{{.+}}) : !cir.ptr<!u8i>
// LLVM-LABEL: @_Z21test_multiple_allocasm(
// LLVM: alloca i8, i64 %{{.+}}
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c b/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c
index 6f57a4b0b1f09..62388a3fb0ea9 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-constant-p.c
@@ -24,7 +24,7 @@ struct foo test0(int expr) {
}
// CIR: cir.func {{.*}} @test0(%[[ARG0:.*]]: !s32i {{.*}}) -> !rec_foo
-// CIR: %[[EXPR_ADDR:.*]] = cir.alloca "expr" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[EXPR_ADDR:.*]] = cir.alloca "expr" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store %[[ARG0]], %[[EXPR_ADDR]]
// CIR: %[[EXPR:.*]] = cir.load{{.*}} %[[EXPR_ADDR]]
// CIR: %[[IS_CONSTANT:.*]] = cir.is_constant %[[EXPR]] : !s32i -> !cir.bool
@@ -48,7 +48,7 @@ int test1(void) {
}
// CIR: cir.func {{.*}} @test1() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -72,7 +72,7 @@ int test2(void) {
}
// CIR: cir.func {{.*}} @test2() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -94,7 +94,7 @@ int test3(void) {
}
// CIR: cir.func {{.*}} @test3() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -118,7 +118,7 @@ int test4(void) {
}
// CIR: cir.func {{.*}} @test4() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -142,7 +142,7 @@ int test5(void) {
}
// CIR: cir.func {{.*}} @test5() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store %[[ONE]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -187,7 +187,7 @@ int test7(void) {
}
// CIR: cir.func {{.*}} @test7() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store %[[ONE]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -207,7 +207,7 @@ int test8(void) {
}
// CIR: cir.func {{.*}} @test8() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -229,7 +229,7 @@ int test9(void) {
}
// CIR: cir.func {{.*}} @test9() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store %[[ZERO]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
@@ -249,7 +249,7 @@ int test10(void) {
}
// CIR: cir.func {{.*}} @test10() -> !s32i
-// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[TMP1:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR: cir.store %[[ONE]], %[[TMP1]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP2:.*]] = cir.load %[[TMP1]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c b/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
index 1f328fd17a600..25ce4c91bab4e 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
@@ -11,9 +11,9 @@ typedef double __m128d __attribute__((__vector_size__(16), __aligned__(16)));
__m128 test_cmpnleps(__m128 A, __m128 B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnleps(
// CIR: %[[ARG0:.*]]: !cir.vector<4 x !cir.float> {{.*}}, %[[ARG1:.*]]: !cir.vector<4 x !cir.float> {{.*}}) -> !cir.vector<4 x !cir.float> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init : !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init : !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -62,9 +62,9 @@ __m128 test_cmpnleps(__m128 A, __m128 B) {
__m128d test_cmpnlepd(__m128d A, __m128d B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnlepd(
// CIR: %[[ARG0:.*]]: !cir.vector<2 x !cir.double> {{.*}}, %[[ARG1:.*]]: !cir.vector<2 x !cir.double> {{.*}}) -> !cir.vector<2 x !cir.double> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init : !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init : !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
@@ -113,9 +113,9 @@ __m128d test_cmpnlepd(__m128d A, __m128d B) {
__m128 test_cmpnltps(__m128 A, __m128 B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnltps(
// CIR: %[[ARG0:.*]]: !cir.vector<4 x !cir.float> {{.*}}, %[[ARG1:.*]]: !cir.vector<4 x !cir.float> {{.*}}) -> !cir.vector<4 x !cir.float> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init : !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init : !cir.ptr<!cir.vector<4 x !cir.float>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
@@ -164,9 +164,9 @@ __m128 test_cmpnltps(__m128 A, __m128 B) {
__m128d test_cmpnltpd(__m128d A, __m128d B) {
// CIR-LABEL: cir.func no_inline dso_local @test_cmpnltpd(
// CIR: %[[ARG0:.*]]: !cir.vector<2 x !cir.double> {{.*}}, %[[ARG1:.*]]: !cir.vector<2 x !cir.double> {{.*}}) -> !cir.vector<2 x !cir.double> {{.*}}{
- // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
- // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
- // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_0:.*]] = cir.alloca "A" align(16) init : !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_1:.*]] = cir.alloca "B" align(16) init : !cir.ptr<!cir.vector<2 x !cir.double>>
+ // CIR: %[[ALLOCA_2:.*]] = cir.alloca "__retval" align(16) : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG0]], %[[ALLOCA_0]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: cir.store %[[ARG1]], %[[ALLOCA_1]] : !cir.vector<2 x !cir.double>, !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[LOAD_0:.*]] = cir.load align(16) %[[ALLOCA_0]] : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp
index 127409d8e3993..30dda98ec58cb 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-offset-of.cpp
@@ -19,10 +19,10 @@ void offset_of_builtin() {
unsigned long d = __builtin_offsetof(Struct, d);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !u64i
// CIR: cir.store {{.*}} %[[CONST_0]], %[[A_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_4:.*]] = cir.const #cir.int<4> : !u64i
@@ -61,10 +61,10 @@ void offset_of_builtin_from_array_element() {
unsigned long d = __builtin_offsetof(StructWithArray, array[3][3].d);
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !u64i -> !cir.ptr<!u64i>
-// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init !u64i -> !cir.ptr<!u64i>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!u64i>
+// CIR: %[[D_ADDR:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !u64i
// CIR: cir.store {{.*}} %[[CONST_0]], %[[A_ADDR]] : !u64i, !cir.ptr<!u64i>
// CIR: %[[CONST_124:.*]] = cir.const #cir.int<124> : !u64i
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c b/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c
index de485bf4b1e4e..0119742e109ba 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-prefetch.c
@@ -10,7 +10,7 @@ void foo(void *a) {
}
// CIR-LABEL: cir.func {{.*}} @foo(
-// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} !cir.ptr<!void>
+// CIR: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!void>>
// CIR: cir.store %arg0, %[[ALLOCA]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[P1:.*]] = cir.load{{.*}} %[[ALLOCA]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: cir.prefetch read locality(3) %[[P1]] : !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp b/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp
index 21e3ae8b6fc4d..110868323f19f 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-printf.cpp
@@ -21,8 +21,8 @@ void func(char const * const str, int i) {
// CIR: cir.func{{.*}} @printf(!cir.ptr<!s8i> {{.*}}, ...) -> !s32i
// CIR: cir.func{{.*}} @_Z4funcPKci(%[[arg0:.+]]: !cir.ptr<!s8i>{{.*}}, %[[arg1:.+]]: !s32i
-// CIR: %[[str_ptr:.+]] = cir.alloca "str" {{.*}} init const !cir.ptr<!s8i> -> !cir.ptr<!cir.ptr<!s8i>>
-// CIR: %[[i_ptr:.+]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR: %[[str_ptr:.+]] = cir.alloca "str" {{.*}} init const : !cir.ptr<!cir.ptr<!s8i>>
+// CIR: %[[i_ptr:.+]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
// CIR: cir.store %[[arg0]], %[[str_ptr]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
// CIR: cir.store %[[arg1]], %[[i_ptr]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[null_ptr:.+]] = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c b/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c
index 1e536f1c17b3d..7f38cbdeddbd9 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-setjmp-longjmp.c
@@ -7,7 +7,7 @@
void test_setjmp(void *env) {
// CIR-LABEL: test_setjmp
// CIR-SAME: [[ENV:%.*]]:
- // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca {{.*}} : !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>>
@@ -44,7 +44,7 @@ void test_setjmp(void *env) {
void test_longjmp(void *env) {
// CIR-LABEL: test_longjmp
// CIR-SAME: [[ENV:%.*]]:
- // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca {{.*}} !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR-NEXT: [[ENV_ALLOCA:%[0-9]+]] = cir.alloca {{.*}} : !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>>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c b/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c
index 4c6a771e4b806..7f52e2732937e 100644
--- a/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c
+++ b/clang/test/CIR/CodeGenBuiltins/builtin-signbit.c
@@ -8,7 +8,7 @@
void test_signbit_positive_zero(){
double positiveZero = +0.0;
int result = __builtin_signbit(positiveZero);
-// CIR: cir.alloca "positiveZero" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "positiveZero" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -22,7 +22,7 @@ void test_signbit_positive_zero(){
void test_signbit_negative_zero(){
double negativeZero = -0.0;
int result = __builtin_signbit(negativeZero);
-// CIR: cir.alloca "negativeZero" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "negativeZero" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<-0.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -36,7 +36,7 @@ void test_signbit_negative_zero(){
void test_signbit_positive_number(){
double positiveNumber = 1.0;
int result = __builtin_signbit(positiveNumber);
-// CIR: cir.alloca "positiveNumber" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "positiveNumber" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<1.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -50,7 +50,7 @@ void test_signbit_positive_number(){
void test_signbit_negative_number(){
double negativeNumber = -1.0;
int result = __builtin_signbit(negativeNumber);
-// CIR: cir.alloca "negativeNumber" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "negativeNumber" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<-1.000000e+00> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -64,7 +64,7 @@ void test_signbit_negative_number(){
void test_signbit_positive_nan(){
double positiveNan = +__builtin_nan("");
int result = __builtin_signbit(positiveNan);
-// CIR: cir.alloca "positiveNan" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "positiveNan" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0x7FF8000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -78,7 +78,7 @@ void test_signbit_positive_nan(){
void test_signbit_negative_nan(){
double negativeNan = -__builtin_nan("");
int result = __builtin_signbit(negativeNan);
-// CIR: cir.alloca "negativeNan" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "negativeNan" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0xFFF8000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -92,7 +92,7 @@ void test_signbit_negative_nan(){
void test_signbit_positive_infinity(){
double positiveInfinity = +__builtin_inf();
int result = __builtin_signbit(positiveInfinity);
-// CIR: cir.alloca "positiveInfinity" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "positiveInfinity" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0x7FF0000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
@@ -106,7 +106,7 @@ void test_signbit_positive_infinity(){
void test_signbit_negative_infinity(){
double negativeInfinity = -__builtin_inf();
int result = __builtin_signbit(negativeInfinity);
-// CIR: cir.alloca "negativeInfinity" {{.*}} init !cir.double -> !cir.ptr<!cir.double>
+// CIR: cir.alloca "negativeInfinity" {{.*}} init : !cir.ptr<!cir.double>
// CIR: cir.const #cir.fp<0xFFF0000000000000> : !cir.double
// CIR: cir.signbit {{.*}} : !cir.double -> !cir.bool
// CIR: cir.cast bool_to_int {{.*}} : !cir.bool -> !s32i
diff --git a/clang/test/CIR/CodeGenCUDA/address-spaces.cu b/clang/test/CIR/CodeGenCUDA/address-spaces.cu
index acd83bd036501..2443384ef0649 100644
--- a/clang/test/CIR/CodeGenCUDA/address-spaces.cu
+++ b/clang/test/CIR/CodeGenCUDA/address-spaces.cu
@@ -158,7 +158,7 @@ __global__ void fn() {
}
// CIR-DEVICE: cir.func {{.*}}@_Z2fnv() {{.*}} {
-// CIR-DEVICE: %[[ALLOCA:.*]] = cir.alloca "i" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CIR-DEVICE: %[[ALLOCA:.*]] = cir.alloca "i" {{.*}} init : !cir.ptr<!s32i>
// CIR-DEVICE: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-DEVICE: cir.store {{.*}}%[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CIR-DEVICE: %[[J:.*]] = cir.get_global @_ZZ2fnvE1j : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenCUDA/device-printf.cu b/clang/test/CIR/CodeGenCUDA/device-printf.cu
index 3ded390570970..ed49dc133943b 100644
--- a/clang/test/CIR/CodeGenCUDA/device-printf.cu
+++ b/clang/test/CIR/CodeGenCUDA/device-printf.cu
@@ -17,7 +17,7 @@ __device__ void print_int() {
}
// CIR: cir.func no_inline dso_local @_Z9print_intv()
-// CIR: %[[#ALLOCA:]] = cir.alloca {{.*}} !rec_anon_struct
+// CIR: %[[#ALLOCA:]] = cir.alloca {{.*}} : !cir.ptr<!rec_anon_struct>
// CIR: %[[#VAL:]] = cir.const #cir.int<42> : !s32i
// CIR: %[[#FIELD:]] = cir.get_member %[[#ALLOCA]][0]
// CIR: cir.store align(4) %[[#VAL]], %[[#FIELD]]
diff --git a/clang/test/CIR/CodeGenCUDA/kernel-call.cu b/clang/test/CIR/CodeGenCUDA/kernel-call.cu
index cf0e908859e09..129976f780be7 100644
--- a/clang/test/CIR/CodeGenCUDA/kernel-call.cu
+++ b/clang/test/CIR/CodeGenCUDA/kernel-call.cu
@@ -31,11 +31,11 @@
// CUDA-NEW-LABEL: cir.func {{.*}} @_Z21__device_stub__kernelif
//
// Check kernel arguments are allocated as local variables
-// CUDA-NEW-DAG: cir.alloca "x" {{.*}} init !s32i
-// CUDA-NEW-DAG: cir.alloca "y" {{.*}} init !cir.float
+// CUDA-NEW-DAG: cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CUDA-NEW-DAG: cir.alloca "y" {{.*}} init : !cir.ptr<!cir.float>
//
// Check void *args[] array is created with correct size (2 args)
-// CUDA-NEW: cir.alloca "kernel_args" {{.*}} !cir.array<!cir.ptr<!void> x 2>
+// CUDA-NEW: cir.alloca "kernel_args" {{.*}} : !cir.ptr<!cir.array<!cir.ptr<!void> x 2>>
// CUDA-NEW: cir.cast array_to_ptrdecay
//
// Check arguments are stored in the args array via ptr_stride indexing
@@ -49,12 +49,12 @@
// CUDA-NEW: cir.store {{.*}} !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
//
// Check dim3 grid_dim and block_dim allocas for launch configuration
-// CUDA-NEW-DAG: cir.alloca "grid_dim" {{.*}} !rec_dim3
-// CUDA-NEW-DAG: cir.alloca "block_dim" {{.*}} !rec_dim3
+// CUDA-NEW-DAG: cir.alloca "grid_dim" {{.*}} : !cir.ptr<!rec_dim3>
+// CUDA-NEW-DAG: cir.alloca "block_dim" {{.*}} : !cir.ptr<!rec_dim3>
//
// Check shared_mem (size_t) and stream allocas
-// CUDA-NEW-DAG: cir.alloca "shared_mem" {{.*}} !u64i
-// CUDA-NEW-DAG: cir.alloca "stream" {{.*}} !cir.ptr<!rec_cudaStream>
+// CUDA-NEW-DAG: cir.alloca "shared_mem" {{.*}} : !cir.ptr<!u64i>
+// CUDA-NEW-DAG: cir.alloca "stream" {{.*}} : !cir.ptr<!cir.ptr<!rec_cudaStream>>
//
// Check __cudaPopCallConfiguration is called with correct argument types
// CUDA-NEW: cir.call @__cudaPopCallConfiguration({{.*}}) : (!cir.ptr<!rec_dim3>, !cir.ptr<!rec_dim3>, !cir.ptr<!u64i>, !cir.ptr<!cir.ptr<!rec_cudaStream>>) -> !s32i
@@ -68,7 +68,7 @@
//
// HIP-NEW: cir.global constant external @_Z6kernelif = #cir.global_view<@_Z21__device_stub__kernelif> : !cir.ptr<!cir.func<(!s32i, !cir.float)>> {alignment = 8 : i64}
// HIP-NEW-LABEL: cir.func {{.*}} @_Z21__device_stub__kernelif
-// HIP-NEW: cir.alloca "stream" {{.*}} !cir.ptr<!rec_hipStream>
+// HIP-NEW: cir.alloca "stream" {{.*}} : !cir.ptr<!cir.ptr<!rec_hipStream>>
// HIP-NEW: cir.call @__hipPopCallConfiguration({{.*}}) : (!cir.ptr<!rec_dim3>, !cir.ptr<!rec_dim3>, !cir.ptr<!u64i>, !cir.ptr<!cir.ptr<!rec_hipStream>>) -> !s32i
// HIP-NEW: cir.get_global @_Z6kernelif : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float)>>>
// HIP-NEW: cir.call @hipLaunchKernel({{.*}}) : (!cir.ptr<!void> {{.*}}, !rec_dim3, !rec_dim3, !cir.ptr<!cir.ptr<!void>>{{.*}}, !u64i{{.*}}, !cir.ptr<!rec_hipStream>{{.*}}) -> (!u32i {llvm.noundef})
@@ -88,10 +88,10 @@ __global__ void kernel(int x, float y) {}
// HIP-NEW-LABEL: cir.func {{.*}} @main
int main(void) {
// Check dim3 temporaries are allocated for grid and block dimensions
- // CUDA-NEW-DAG: cir.alloca "agg.tmp0" {{.*}} !rec_dim3
- // CUDA-NEW-DAG: cir.alloca "agg.tmp1" {{.*}} !rec_dim3
- // HIP-NEW-DAG: cir.alloca "agg.tmp0" {{.*}} !rec_dim3
- // HIP-NEW-DAG: cir.alloca "agg.tmp1" {{.*}} !rec_dim3
+ // CUDA-NEW-DAG: cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_dim3>
+ // CUDA-NEW-DAG: cir.alloca "agg.tmp1" {{.*}} : !cir.ptr<!rec_dim3>
+ // HIP-NEW-DAG: cir.alloca "agg.tmp0" {{.*}} : !cir.ptr<!rec_dim3>
+ // HIP-NEW-DAG: cir.alloca "agg.tmp1" {{.*}} : !cir.ptr<!rec_dim3>
//
// Check dim3 constructors are called for grid and block dimensions
// CUDA-NEW: cir.call @_ZN4dim3C1Ejjj({{.*}}) : (!cir.ptr<!rec_dim3> {llvm.align = 4 : i64, llvm.dereferenceable = 12 : i64, llvm.nonnull, llvm.noundef}, !u32i {llvm.noundef}, !u32i {llvm.noundef}, !u32i {llvm.noundef}) -> ()
diff --git a/clang/test/CIR/CodeGenCXX/global-refs.cpp b/clang/test/CIR/CodeGenCXX/global-refs.cpp
index 470c052f751d6..a9e38edff2749 100644
--- a/clang/test/CIR/CodeGenCXX/global-refs.cpp
+++ b/clang/test/CIR/CodeGenCXX/global-refs.cpp
@@ -133,7 +133,7 @@ void use() {
// CIR-LABEL: cir.func{{.*}}use
WithCtor &local = ExternRef;
- // CIR-NEXT: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} init const !cir.ptr<!rec_WithCtor> -> !cir.ptr<!cir.ptr<!rec_WithCtor>>
+ // CIR-NEXT: %[[LOCAL:.*]] = cir.alloca "local" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_WithCtor>>
// CIR-NEXT: %[[EXT_REF:.*]] = cir.get_global @ExternRef : !cir.ptr<!cir.ptr<!rec_WithCtor>>
// CIR-NEXT: %[[EXT_REF_LOAD:.*]] = cir.load %[[EXT_REF]] : !cir.ptr<!cir.ptr<!rec_WithCtor>>, !cir.ptr<!rec_WithCtor>
// CIR-NEXT: cir.store{{.*}}%[[EXT_REF_LOAD]], %[[LOCAL]]
diff --git a/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp b/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp
index 565cafa568f19..5010c64bdd8dc 100644
--- a/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp
+++ b/clang/test/CIR/CodeGenCXX/lvalue-nttp.cpp
@@ -30,7 +30,7 @@ struct Struct{Struct(); Struct(int);};
Struct s;
template void templ<s>();
// CIR: cir.func{{.*}}@_Z5templITnRDaL_Z1sEEvv()
-// CIR-NEXT: %[[TEMP:.*]] = cir.alloca {{.*}} !rec_Struct -> !cir.ptr<!rec_Struct>
+// CIR-NEXT: %[[TEMP:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_Struct>
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1>
// CIR-NEXT: cir.call @_ZN6StructC1Ei(%[[TEMP]], %[[ONE]])
// CIR-NEXT: %[[GLOB:.*]] = cir.get_global @s : !cir.ptr<!rec_Struct>
diff --git a/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp b/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp
index 7204826f9b666..5d7e5f54b4b79 100644
--- a/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp
+++ b/clang/test/CIR/CodeGenCXX/new-array-init-list-non-trivial-dtor.cpp
@@ -27,7 +27,7 @@ void cleanup_const_exact() { new Throws[3]{1, 2, 3}; }
// call we update arrayinit.endOfInit so the EH cleanup destroys only the
// elements that were actually constructed before the throw.
// CIR-LABEL: cir.func{{.*}} @_Z19cleanup_const_exactv(
-// CIR: %[[INIT_END:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} {{.*}} -> !cir.ptr<!cir.ptr<!rec_Throws>>
+// CIR: %[[INIT_END:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} : !cir.ptr<!cir.ptr<!rec_Throws>>
// CIR: %[[ELT0:.*]] = cir.cast bitcast %{{.*}} : !cir.ptr<!void> -> !cir.ptr<!rec_Throws>
// CIR: cir.cleanup.scope {
// CIR: cir.store align(8) %[[ELT0]], %[[INIT_END]]
@@ -130,7 +130,7 @@ void cleanup_const_exact() { new Throws[3]{1, 2, 3}; }
void cleanup_const_partial() { new Throws[5]{1, 2, 3}; }
// CIR-LABEL: cir.func{{.*}} @_Z21cleanup_const_partialv(
-// CIR: %[[INIT_END:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} {{.*}} -> !cir.ptr<!cir.ptr<!rec_Throws>>
+// CIR: %[[INIT_END:.*]] = cir.alloca "arrayinit.endOfInit" {{.*}} : !cir.ptr<!cir.ptr<!rec_Throws>>
// CIR: %[[ELT0:.*]] = cir.cast bitcast %{{.*}} : !cir.ptr<!void> -> !cir.ptr<!rec_Throws>
// CIR: cir.cleanup.scope {
// CIR: cir.store align(8) %[[ELT0]], %[[INIT_END]]
diff --git a/clang/test/CIR/CodeGenCXX/new-array-init.cpp b/clang/test/CIR/CodeGenCXX/new-array-init.cpp
index 8374fe1d760f1..6e94b8bc275d7 100644
--- a/clang/test/CIR/CodeGenCXX/new-array-init.cpp
+++ b/clang/test/CIR/CodeGenCXX/new-array-init.cpp
@@ -16,7 +16,7 @@
// CIR-LABEL: cir.func{{.*}} @_Z2fni(
// CHECK-LABEL: define{{.*}} void @_Z2fni
void fn(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>
// CIR: %[[N_U64_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
@@ -71,7 +71,7 @@ void fn(int n) {
// CIR-LABEL: cir.func {{.*}}@_Z8fn_pareni(
// LLVM-LABEL: define{{.*}} void @_Z8fn_pareni
void fn_paren(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>
// CIR: %[[N_U64_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
@@ -280,7 +280,7 @@ void const_sufficient_paren() {
// CIR-LABEL: cir.func {{.*}}@_Z15string_nonconsti(
// LLVM-LABEL: define{{.*}} void @_Z15string_nonconsti
void string_nonconst(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init : !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
@@ -316,7 +316,7 @@ void string_nonconst(int n) {
// CIR-LABEL: cir.func no_inline dso_local @_Z21string_nonconst_pareni(
// LLVM-LABEL: define{{.*}} void @_Z21string_nonconst_pareni
void string_nonconst_paren(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init : !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
@@ -352,7 +352,7 @@ void string_nonconst_paren(int n) {
// CIR-LABEL: cir.func {{.*}}@_Z33string_nonconst_paren_extra_pareni(
// LLVM-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni
void string_nonconst_paren_extra_paren(int n) {
- // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[N_ALLOCA:.*]] = cir.alloca "n" align(4) init : !cir.ptr<!s32i>
// CIR: %[[N_LOAD:.*]] = cir.load {{.*}} %[[N_ALLOCA]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[N_LOAD]] : !s32i -> !u64i
// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
@@ -508,7 +508,7 @@ void aggr_exact() {
// CIR-LABEL: cir.func {{.*}}@_Z15aggr_sufficienti(
// LLVM-LABEL: define{{.*}} void @_Z15aggr_sufficienti
void aggr_sufficient(int n) {
- // CIR: %[[ARG:.*]] = cir.alloca "n" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CIR: %[[ARG:.*]] = cir.alloca "n" align(4) init : !cir.ptr<!s32i>
// CIR: %[[GET_N:.*]] = cir.load {{.*}}%[[ARG:.*]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[N_CAST:.*]] = cir.cast integral %[[GET_N]] : !s32i -> !u64i
// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !u64i
diff --git a/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp b/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp
index c699b43ddc2c3..42e30ec0c3176 100644
--- a/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp
+++ b/clang/test/CIR/CodeGenCXX/simple-reinterpret-const-cast.cpp
@@ -8,7 +8,7 @@ void test_const_cast(const S &s) {
const_cast<S&>(s).do_thing();
}
// CIR: cir.func {{.*}}@_Z15test_const_castRK1S(%[[ARG:.*]]: !cir.ptr<!rec_S>{{.*}}) {{.*}}{
-// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca "s" {{.*}} init const !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_S>>
// CIR-NEXT: cir.store %[[ARG]], %[[ARG_ALLOCA]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
// CIR-NEXT: %[[ARG_LOAD:.*]] = cir.load %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
// CIR-NEXT: cir.call @_ZN1S8do_thingEv(%[[ARG_LOAD]])
@@ -26,7 +26,7 @@ void test_reinterpet_cast(void *&data) {
call_with_ri_cast(reinterpret_cast<int*&>(data));
}
// CIR: cir.func {{.*}}@_Z20test_reinterpet_castRPv(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!void>>{{.*}}) {{.*}}{
-// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca "data" {{.*}} init const !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
+// CIR-NEXT: %[[ARG_ALLOCA:.*]] = cir.alloca "data" {{.*}} init const : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
// CIR-NEXT: cir.store %[[ARG]], %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
// CIR-NEXT: %[[ARG_LOAD:.*]] = cir.load %[[ARG_ALLOCA]] : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>, !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: %[[RI_CAST:.*]] = cir.cast bitcast %[[ARG_LOAD]] : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!rec_S>>
diff --git a/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp b/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp
index 881bdf5ded3ee..c951725198dce 100644
--- a/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp
+++ b/clang/test/CIR/CodeGenCXX/sizeof-pack.cpp
@@ -32,8 +32,8 @@ void test() {
// LLVM-DAG: @__const._Z3fooIJEEDav.values = private constant [1 x i32] zeroinitializer
// CIR: cir.func {{.*}}@_Z3fooIJEEDav()
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[VAL_ARR:.*]] = cir.alloca "values" {{.*}} init !cir.array<!s32i x 1> -> !cir.ptr<!cir.array<!s32i x 1>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[VAL_ARR:.*]] = cir.alloca "values" {{.*}} init : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[GET_GLOB_VAL:.*]] = cir.get_global @__const._Z3fooIJEEDav.values : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: cir.copy %[[GET_GLOB_VAL]] to %[[VAL_ARR]] : !cir.ptr<!cir.array<!s32i x 1>>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
@@ -55,8 +55,8 @@ void test() {
// OGCG: ret i64 0
// CIR: cir.func {{.*}}@_Z3fooIJ2S12S22S3EEDav()
-// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} !u64i -> !cir.ptr<!u64i>
-// CIR: %[[VAL_ARR:.*]] = cir.alloca "values" {{.*}} init !cir.array<!s32i x 4> -> !cir.ptr<!cir.array<!s32i x 4>>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!u64i>
+// CIR: %[[VAL_ARR:.*]] = cir.alloca "values" {{.*}} init : !cir.ptr<!cir.array<!s32i x 4>>
// CIR: %[[GET_GLOB_VAL:.*]] = cir.get_global @__const._Z3fooIJ2S12S22S3EEDav.values : !cir.ptr<!cir.array<!s32i x 4>>
// CIR: cir.copy %[[GET_GLOB_VAL]] to %[[VAL_ARR]] : !cir.ptr<!cir.array<!s32i x 4>>
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u64i
diff --git a/clang/test/CIR/CodeGenCXX/typeid.cpp b/clang/test/CIR/CodeGenCXX/typeid.cpp
index 7b42910235359..47d4e57d31347 100644
--- a/clang/test/CIR/CodeGenCXX/typeid.cpp
+++ b/clang/test/CIR/CodeGenCXX/typeid.cpp
@@ -67,7 +67,7 @@ const std::type_info &A10_c_ti = typeid(char const[10]);
// LLVM-LABEL: define{{.*}} ptr @_ZN5Test11fEPv
// LLVM-SAME: personality ptr @__gxx_personality_v0
const char *f(void *arg) {
- // CIR: %[[ARG:.*]] = cir.alloca "arg" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "arg" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
try {
// CIR: %[[ARG_VALUE:.*]] = cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR-NEXT: %[[ARG_CAST:.*]] = cir.cast bitcast %[[ARG_VALUE]] : !cir.ptr<!void> -> !cir.ptr<!rec_Test13A3AA>
diff --git a/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp b/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp
index 111e68bda459c..9de012bd9fd0b 100644
--- a/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp
+++ b/clang/test/CIR/CodeGenCXX/vtable-virt-thunk-adj.cpp
@@ -27,7 +27,7 @@ extern constexpr Item items[] = {
};
// CIR-LABEL: cir.func {{.*}}@_ZTv0_n24_N1CD1Ev
-// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
// CIR: %[[THIS_CAST:.*]] = cir.cast bitcast %[[THIS_LOAD]] : !cir.ptr<!rec_C> -> !cir.ptr<!u8i>
// CIR: %[[VTBL_PTR:.*]] = cir.vtable.get_vptr %[[THIS_CAST]] : !cir.ptr<!u8i> -> !cir.ptr<!cir.vptr>
@@ -51,7 +51,7 @@ extern constexpr Item items[] = {
// LLVM: call void @_ZN1CD1Ev(ptr {{.*}}%[[APPLY_OFFSET]])
//
// CIR-LABEL: cir.func {{.*}}@_ZTv0_n24_N1CD0Ev
-// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+// CIR: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_C>>
// CIR: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
// CIR: %[[THIS_CAST:.*]] = cir.cast bitcast %[[THIS_LOAD]] : !cir.ptr<!rec_C> -> !cir.ptr<!u8i>
// CIR: %[[VTBL_PTR:.*]] = cir.vtable.get_vptr %[[THIS_CAST]] : !cir.ptr<!u8i> -> !cir.ptr<!cir.vptr>
diff --git a/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp b/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp
index 80fb7dad563c9..e10a47b7acea5 100644
--- a/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp
+++ b/clang/test/CIR/CodeGenCXX/x86_64-arguments.cpp
@@ -134,8 +134,8 @@ namespace test5 {
}
// CIR-LABEL: cir.func {{.*}} @_ZN5test51gEv
-// CIR: cir.alloca {{.*}} !rec_{{.*}}Y
-// CIR: cir.alloca {{.*}} !rec_{{.*}}X
+// CIR: cir.alloca {{.*}} : !cir.ptr<!rec_{{.*}}Y>
+// CIR: cir.alloca {{.*}} : !cir.ptr<!rec_{{.*}}X>
// CIR: cir.call @_ZN5test54getXEv
// CIR: cir.call @_ZN5test51X1fEv
// CIR: cir.call @_ZN5test55takeYERKNS_1YEi
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp
index a8ecc8dfe4a3c..673e5e24690dd 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-capture.cpp
@@ -9,10 +9,10 @@ struct HasOps {
void use(int x, int v, float f, HasOps ops) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[V_ARG:.*]]: !s32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}, %[[OPS_ARG:.*]]: !rec_HasOps{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[V_ALLOCA:.*]] = cir.alloca "v" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca "ops" {{.*}} init !rec_HasOps -> !cir.ptr<!rec_HasOps>
+ // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[V_ALLOCA:.*]] = cir.alloca "v" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca "ops" {{.*}} init : !cir.ptr<!rec_HasOps>
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[V_ARG]], %[[V_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[F_ARG]], %[[F_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
@@ -26,7 +26,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -43,7 +43,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -62,7 +62,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -79,7 +79,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -97,7 +97,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -121,7 +121,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -145,7 +145,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -170,7 +170,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -195,7 +195,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -223,7 +223,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -250,7 +250,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -275,7 +275,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -302,7 +302,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -342,7 +342,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -363,7 +363,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -383,7 +383,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -404,7 +404,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -426,7 +426,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -447,7 +447,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.read %[[V_ALLOCA]] = %[[X_ALLOCA]] : !cir.ptr<!s32i>, !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -467,7 +467,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
@@ -488,7 +488,7 @@ void use(int x, int v, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.capture {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[X_VAR:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[X_VAR_ALLOC:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[X_VAR]], %[[X_VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[X_VAR_LOAD:.*]] = cir.load{{.*}} %[[X_VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp
index 84306f9a42d2a..d624ad1bfe840 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-read.cpp
@@ -2,9 +2,9 @@
void use(int x, unsigned int y, float f) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[Y_ARG:.*]]: !u32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}{
- // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca "y" {{.*}} init !u32i -> !cir.ptr<!u32i>
- // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOC]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[Y_ARG]], %[[Y_ALLOC]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[F_ARG]], %[[F_ALLOC]] : !cir.float, !cir.ptr<!cir.float>
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp
index de49ec6cf7239..f2a9836a44154 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-update.cpp
@@ -7,10 +7,10 @@ struct HasOps {
void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[Y_ARG:.*]]: !u32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}, %[[OPS_ARG:.*]]: !rec_HasOps{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[Y_ALLOCA:.*]] = cir.alloca "y" {{.*}} init !u32i -> !cir.ptr<!u32i>
- // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca "ops" {{.*}} init !rec_HasOps -> !cir.ptr<!rec_HasOps>
+ // CHECK-NEXT: %[[X_ALLOCA:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[Y_ALLOCA:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[F_ALLOCA:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[OPS_ALLOCA:.*]] = cir.alloca "ops" {{.*}} init : !cir.ptr<!rec_HasOps>
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[Y_ARG]], %[[Y_ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[F_ARG]], %[[F_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
@@ -18,7 +18,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!s32i>, !s32i
@@ -33,7 +33,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[Y_ALLOCA]] : !cir.ptr<!u32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !u32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !u32i, !cir.ptr<!u32i>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!u32i>, !u32i
@@ -48,7 +48,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[F_ALLOCA]] : !cir.ptr<!cir.float> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !cir.float{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -63,7 +63,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[F_LOAD:.*]] = cir.load{{.*}} %[[F_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
@@ -81,7 +81,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[F_ALLOCA]] : !cir.ptr<!cir.float> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !cir.float{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
//
// CHECK-NEXT: %[[Y_LOAD:.*]] = cir.load{{.*}} %[[Y_ALLOCA]] : !cir.ptr<!u32i>, !u32i
@@ -98,7 +98,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[Y_ALLOCA]] : !cir.ptr<!u32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !u32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !u32i, !cir.ptr<!u32i>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!u32i>, !u32i
@@ -116,7 +116,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: acc.atomic.update %[[X_ALLOCA]] : !cir.ptr<!s32i> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !s32i{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !s32i, !cir.ptr<!s32i>
//
// CHECK-NEXT: %[[CALL:.*]] = cir.call {{.*}}(%[[OPS_ALLOCA]]) : (!cir.ptr<!rec_HasOps> {{.*}}) -> (!s32i{{.*}})
@@ -135,7 +135,7 @@ void use(int x, unsigned int y, float f, HasOps ops) {
// CHECK-NEXT: %[[X_CAST:.*]] = builtin.unrealized_conversion_cast %[[BOOL_CAST]] : !cir.bool to i1
// CHECK-NEXT: acc.atomic.update if(%[[X_CAST]]) %[[F_ALLOCA]] : !cir.ptr<!cir.float> {
// CHECK-NEXT: ^bb0(%[[RECIPE_ARG:.*]]: !cir.float{{.*}}):
- // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[TEMP_ALLOCA:.*]] = cir.alloca "x_var" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[RECIPE_ARG]], %[[TEMP_ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
//
// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load{{.*}} %[[TEMP_ALLOCA]] : !cir.ptr<!cir.float>, !cir.float
diff --git a/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp b/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp
index c2bbbb670cd75..9799c5101b3e6 100644
--- a/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/atomic-write.cpp
@@ -9,10 +9,10 @@ struct ConvertsToScalar {
void use(int x, unsigned int y, float f, ConvertsToScalar cts) {
// CHECK: cir.func{{.*}}(%[[X_ARG:.*]]: !s32i{{.*}}, %[[Y_ARG:.*]]: !u32i{{.*}}, %[[F_ARG:.*]]: !cir.float{{.*}}){{.*}}, %[[CTS_ARG:.*]]: !rec_ConvertsToScalar{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca "y" {{.*}} init !u32i -> !cir.ptr<!u32i>
- // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca "f" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %[[CTS_ALLOC:.*]] = cir.alloca "cts" {{.*}} init !rec_ConvertsToScalar -> !cir.ptr<!rec_ConvertsToScalar>
+ // CHECK-NEXT: %[[X_ALLOC:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[Y_ALLOC:.*]] = cir.alloca "y" {{.*}} init : !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[F_ALLOC:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[CTS_ALLOC:.*]] = cir.alloca "cts" {{.*}} init : !cir.ptr<!rec_ConvertsToScalar>
//
// CHECK-NEXT: cir.store %[[X_ARG]], %[[X_ALLOC]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[Y_ARG]], %[[Y_ALLOC]] : !u32i, !cir.ptr<!u32i>
diff --git a/clang/test/CIR/CodeGenOpenACC/cache.c b/clang/test/CIR/CodeGenOpenACC/cache.c
index 98322ecb3d240..8920d0037a125 100644
--- a/clang/test/CIR/CodeGenOpenACC/cache.c
+++ b/clang/test/CIR/CodeGenOpenACC/cache.c
@@ -4,9 +4,9 @@ void acc_cache() {
// CHECK: cir.func{{.*}} @acc_cache()
int iArr[10];
- // CHECK-NEXT: %[[IARR:.*]] = cir.alloca "iArr" {{.*}} !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
+ // CHECK-NEXT: %[[IARR:.*]] = cir.alloca "iArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 10>>
float fArr[10];
- // CHECK-NEXT: %[[FARR:.*]] = cir.alloca "fArr" {{.*}} !cir.array<!cir.float x 10> -> !cir.ptr<!cir.array<!cir.float x 10>>
+ // CHECK-NEXT: %[[FARR:.*]] = cir.alloca "fArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 10>>
#pragma acc cache(iArr[1], fArr[1:5])
// This does nothing, as it is not in a loop.
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copy.c b/clang/test/CIR/CodeGenOpenACC/combined-copy.c
index 7e16dcf002bf6..933579e3054b4 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copy.c
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copy.c
@@ -3,17 +3,17 @@
int global;
void acc_compute(int parmVar) {
// CHECK: cir.func{{.*}} @acc_compute(%[[ARG:.*]]: !s32i{{.*}})
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
int localVar1;
short localVar2;
float localVar3;
- // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca "localVar2" {{.*}} !s16i -> !cir.ptr<!s16i>
- // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca "localVar3" {{.*}} !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca "localPointer" {{.*}} !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
- // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca "localArray" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
- // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca "localArrayOfPtrs" {{.*}} !cir.array<!cir.ptr<!cir.float> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>
- // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca "threeDArray" {{.*}} !cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>
+ // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca "localVar1" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca "localVar2" {{.*}} : !cir.ptr<!s16i>
+ // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca "localVar3" {{.*}} : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca "localPointer" {{.*}} : !cir.ptr<!cir.ptr<!s16i>>
+ // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca "localArray" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca "localArrayOfPtrs" {{.*}} : !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>
+ // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca "threeDArray" {{.*}} : !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
#pragma acc parallel loop copy(localVar1, parmVar) copy(localVar2) copy(localVar3, parmVar)
@@ -773,7 +773,7 @@ typedef struct StructTy {
void acc_compute_members() {
// CHECK: cir.func{{.*}} @acc_compute_members()
Struct localStruct;
- // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca "localStruct" {{.*}} !rec_StructTy -> !cir.ptr<!rec_StructTy>
+ // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca "localStruct" {{.*}} : !cir.ptr<!rec_StructTy>
#pragma acc parallel loop copy(localStruct)
for(int i = 0; i < 5; ++i);
@@ -1082,7 +1082,7 @@ typedef struct OuterTy {
void copy_member_of_array_element_member() {
// CHECK: cir.func{{.*}} @copy_member_of_array_element_member()
Outer outer;
- // CHECK-NEXT: %[[OUTER:.*]] = cir.alloca "outer" {{.*}} !rec_OuterTy -> !cir.ptr<!rec_OuterTy>
+ // CHECK-NEXT: %[[OUTER:.*]] = cir.alloca "outer" {{.*}} : !cir.ptr<!rec_OuterTy>
#pragma acc parallel loop copy(outer.inner[2].b)
for(int i = 0; i < 5; ++i);
@@ -1103,7 +1103,7 @@ void copy_member_of_array_element_member() {
void modifier_list() {
// CHECK: cir.func{{.*}} @modifier_list()
int localVar;
- // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca "localVar" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca "localVar" {{.*}} : !cir.ptr<!s32i>
#pragma acc parallel loop copy(always:localVar)
for(int i = 0; i < 5; ++i);
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp b/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp
index b6c4f2c5c9089..ac1ba566e1a7f 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copy.cpp
@@ -11,7 +11,7 @@ struct StructTy {
void InlineFunc() {
// CHECK: cir.func {{.*}}InlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
@@ -221,7 +221,7 @@ void InlineUse() {
void StructTy::OutlineFunc() {
// CHECK: cir.func {{.*}}OutlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
#pragma acc parallel loop copy(scalarMember)
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c b/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c
index 7b6e9401521ef..699e07e1e63db 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copyin-copyout-create.c
@@ -2,12 +2,12 @@
void acc_combined(int parmVar) {
// CHECK: cir.func{{.*}} @acc_combined(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
int localVar1;
- // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} : !cir.ptr<!s32i>
float localVar2;
- // CHECK-NEXT: %[[LV2:.*]] = cir.alloca "localVar2" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[LV2:.*]] = cir.alloca "localVar2" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]]
#pragma acc parallel loop copyin(parmVar) copyout(localVar1) create(localVar2)
for(int i = 0; i < 5; ++i);
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp b/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp
index 4c1ddb0d458c1..31f60aa6a1d05 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-firstprivate-clause.cpp
@@ -21,7 +21,7 @@ struct HasDtor {
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -32,7 +32,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.float> {{.*}}):
@@ -43,7 +43,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
@@ -53,7 +53,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
@@ -63,7 +63,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
@@ -73,7 +73,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -87,7 +87,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -96,7 +96,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -123,7 +123,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -132,7 +132,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -159,7 +159,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -168,7 +168,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -194,7 +194,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -203,7 +203,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -229,7 +229,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -238,7 +238,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -264,7 +264,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -273,7 +273,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -302,7 +302,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -331,29 +331,29 @@ extern "C" void acc_combined() {
// CHECK: cir.func{{.*}} @acc_combined()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} : !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} : !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel loop firstprivate(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp b/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
index f5d3086d1a661..c7bd7b86b1b61 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
@@ -18,35 +18,35 @@ struct HasDtor {
// Int
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// Float
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -54,7 +54,7 @@ struct HasDtor {
// HasDtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -65,41 +65,41 @@ struct HasDtor {
// int[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -124,7 +124,7 @@ struct HasDtor {
// HasDtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -133,7 +133,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -161,29 +161,29 @@ extern "C" void acc_combined() {
// CHECK: cir.func{{.*}} @acc_combined()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} : !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} : !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel loop private(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
index 94aba94f23f8c..ff1d3950ab3c2 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp
@@ -24,7 +24,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -70,7 +70,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -116,7 +116,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -201,7 +201,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -286,7 +286,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -320,7 +320,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -354,7 +354,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -388,7 +388,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -472,7 +472,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -557,7 +557,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -565,7 +565,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -626,7 +626,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -634,7 +634,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -696,7 +696,7 @@ void acc_combined() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -704,7 +704,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -803,7 +803,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -811,7 +811,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -910,7 +910,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -918,7 +918,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -967,7 +967,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -975,7 +975,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1024,7 +1024,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1032,7 +1032,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1081,7 +1081,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1089,7 +1089,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1189,7 +1189,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1197,7 +1197,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1298,13 +1298,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1345,7 +1345,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1404,13 +1404,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1451,7 +1451,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1510,13 +1510,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1557,7 +1557,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1658,13 +1658,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1705,7 +1705,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1806,13 +1806,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,7 +1847,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1894,13 +1894,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,7 +1935,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1982,13 +1982,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,7 +2023,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2070,13 +2070,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2117,7 +2117,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2216,13 +2216,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2263,7 +2263,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp
index fb9d3d4e303a1..b4259d1b6ab2d 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp
@@ -8,7 +8,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -146,7 +146,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -176,7 +176,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -184,7 +184,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -214,7 +214,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -222,7 +222,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -259,7 +259,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -267,7 +267,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -304,7 +304,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -312,7 +312,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -352,7 +352,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -360,7 +360,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -401,13 +401,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -435,7 +435,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -465,13 +465,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -499,7 +499,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -529,13 +529,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -563,7 +563,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,13 +600,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -634,7 +634,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -671,13 +671,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -705,7 +705,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -745,13 +745,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -779,7 +779,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp
index 8c7efe8548a09..018807f626e45 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-inline-ops.cpp
@@ -28,7 +28,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -59,7 +59,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -90,7 +90,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -127,7 +127,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -164,7 +164,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -195,7 +195,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -226,7 +226,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -257,7 +257,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -289,7 +289,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -322,8 +322,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -359,7 +359,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -387,7 +387,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -407,7 +407,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -503,7 +503,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -530,7 +530,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -550,7 +550,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -646,7 +646,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -679,7 +679,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -699,7 +699,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -795,7 +795,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -828,7 +828,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -848,7 +848,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -944,7 +944,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -971,7 +971,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -991,8 +991,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1029,7 +1029,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1056,7 +1056,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1076,8 +1076,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1113,7 +1113,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1140,7 +1140,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1161,7 +1161,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1257,7 +1257,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1287,7 +1287,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1307,8 +1307,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1345,7 +1345,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1375,7 +1375,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1396,13 +1396,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1443,7 +1443,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1472,7 +1472,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1499,13 +1499,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1546,7 +1546,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1575,7 +1575,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1602,13 +1602,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1649,7 +1649,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1684,7 +1684,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1711,13 +1711,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1758,7 +1758,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1820,13 +1820,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1867,7 +1867,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1896,7 +1896,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1923,13 +1923,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1970,7 +1970,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1999,7 +1999,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2026,13 +2026,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2073,7 +2073,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2102,7 +2102,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2129,13 +2129,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2176,7 +2176,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2208,7 +2208,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2235,13 +2235,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2282,7 +2282,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2314,7 +2314,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp
index 7b6f5d5d4deff..d347616452bae 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-int.cpp
@@ -8,7 +8,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -104,7 +104,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -121,7 +121,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -164,7 +164,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -518,7 +518,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -526,7 +526,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -567,13 +567,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -601,7 +601,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -631,13 +631,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -665,7 +665,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -695,13 +695,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -729,7 +729,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -766,13 +766,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -800,7 +800,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -837,13 +837,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -871,7 +871,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -901,13 +901,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -935,7 +935,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -965,13 +965,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -999,7 +999,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1029,13 +1029,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1063,7 +1063,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1103,13 +1103,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1137,7 +1137,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp
index 27d9e8fbc04f4..a1e50feaa1e78 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-outline-ops.cpp
@@ -27,7 +27,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -58,7 +58,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -126,7 +126,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -163,7 +163,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -194,7 +194,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -225,7 +225,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -256,7 +256,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -288,7 +288,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -321,8 +321,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -358,7 +358,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -386,7 +386,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -406,7 +406,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -502,7 +502,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -529,7 +529,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -549,7 +549,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -645,7 +645,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -678,7 +678,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -698,7 +698,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -794,7 +794,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -827,7 +827,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -847,7 +847,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -943,7 +943,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -970,7 +970,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -990,8 +990,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1028,7 +1028,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1055,7 +1055,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1075,8 +1075,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1112,7 +1112,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1139,7 +1139,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1160,7 +1160,7 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1256,7 +1256,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1286,7 +1286,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1306,8 +1306,8 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1344,7 +1344,7 @@ void acc_combined() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1374,7 +1374,7 @@ void acc_combined() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1395,13 +1395,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1442,7 +1442,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1471,7 +1471,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1498,13 +1498,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1545,7 +1545,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1574,7 +1574,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1601,13 +1601,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1648,7 +1648,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1683,7 +1683,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1710,13 +1710,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1757,7 +1757,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1792,7 +1792,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1819,13 +1819,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1866,7 +1866,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1895,7 +1895,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1922,13 +1922,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1969,7 +1969,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1998,7 +1998,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2025,13 +2025,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2072,7 +2072,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2101,7 +2101,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2128,13 +2128,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2175,7 +2175,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2207,7 +2207,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2234,13 +2234,13 @@ void acc_combined() {
#pragma acc parallel loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2281,7 +2281,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2313,7 +2313,7 @@ void acc_combined() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/combined.cpp b/clang/test/CIR/CodeGenOpenACC/combined.cpp
index 447e9443d7d15..d0c78d0cc34aa 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined.cpp
@@ -2,8 +2,8 @@
extern "C" void acc_combined(int N, int cond) {
// CHECK: cir.func{{.*}} @acc_combined(%[[ARG_N:.*]]: !s32i {{.*}}, %[[ARG_COND:.*]]: !s32i {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca "N" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca "N" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_N]], %[[ALLOCA_N]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_COND]], %[[COND]] : !s32i, !cir.ptr<!s32i>
@@ -1013,8 +1013,8 @@ extern "C" void acc_combined(int N, int cond) {
}
extern "C" void acc_combined_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_combined_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-copy.c b/clang/test/CIR/CodeGenOpenACC/compute-copy.c
index 7c774000722c7..f35bfe6f996e0 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-copy.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-copy.c
@@ -3,17 +3,17 @@
int global;
void acc_compute(int parmVar) {
// CHECK: cir.func{{.*}} @acc_compute(%[[ARG:.*]]: !s32i{{.*}})
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
int localVar1;
short localVar2;
float localVar3;
- // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca "localVar2" {{.*}} !s16i -> !cir.ptr<!s16i>
- // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca "localVar3" {{.*}} !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca "localPointer" {{.*}} !cir.ptr<!s16i> -> !cir.ptr<!cir.ptr<!s16i>>
- // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca "localArray" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
- // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca "localArrayOfPtrs" {{.*}} !cir.array<!cir.ptr<!cir.float> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>
- // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca "threeDArray" {{.*}} !cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>
+ // CHECK-NEXT: %[[LOCAL1:.*]] = cir.alloca "localVar1" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOCAL2:.*]] = cir.alloca "localVar2" {{.*}} : !cir.ptr<!s16i>
+ // CHECK-NEXT: %[[LOCAL3:.*]] = cir.alloca "localVar3" {{.*}} : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[LOCALPTR:.*]] = cir.alloca "localPointer" {{.*}} : !cir.ptr<!cir.ptr<!s16i>>
+ // CHECK-NEXT: %[[LOCALARRAY:.*]] = cir.alloca "localArray" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[LOCALARRAYOFPTRS:.*]] = cir.alloca "localArrayOfPtrs" {{.*}} : !cir.ptr<!cir.array<!cir.ptr<!cir.float> x 5>>
+ // CHECK-NEXT: %[[THREEDARRAY:.*]] = cir.alloca "threeDArray" {{.*}} : !cir.ptr<!cir.array<!cir.array<!cir.array<!cir.double x 7> x 6> x 5>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
@@ -646,7 +646,7 @@ typedef struct StructTy {
void acc_compute_members() {
// CHECK: cir.func{{.*}} @acc_compute_members()
Struct localStruct;
- // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca "localStruct" {{.*}} !rec_StructTy -> !cir.ptr<!rec_StructTy>
+ // CHECK-NEXT: %[[LOCALSTRUCT:.*]] = cir.alloca "localStruct" {{.*}} : !cir.ptr<!rec_StructTy>
#pragma acc parallel copy(localStruct)
;
@@ -899,7 +899,7 @@ void acc_compute_members() {
void modifier_list() {
// CHECK: cir.func{{.*}} @modifier_list()
int localVar;
- // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca "localVar" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LOCALVAR:.*]] = cir.alloca "localVar" {{.*}} : !cir.ptr<!s32i>
#pragma acc parallel copy(always:localVar)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp b/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp
index bf742882cebe5..746ce9d3f16eb 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-copy.cpp
@@ -11,7 +11,7 @@ struct StructTy {
void InlineFunc() {
// CHECK: cir.func {{.*}}InlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
@@ -185,7 +185,7 @@ void InlineUse() {
void StructTy::OutlineFunc() {
// CHECK: cir.func {{.*}}OutlineFunc{{.*}}
- // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init !cir.ptr<!rec_StructTy> -> !cir.ptr<!cir.ptr<!rec_StructTy>>
+ // CHECK-NEXT: %[[THIS:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: cir.store %[[THIS_ARG:.*]], %[[THIS]] : !cir.ptr<!rec_StructTy>, !cir.ptr<!cir.ptr<!rec_StructTy>>
// CHECK-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS]] : !cir.ptr<!cir.ptr<!rec_StructTy>>, !cir.ptr<!rec_StructTy>
#pragma acc parallel copy(scalarMember)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c b/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c
index d5aeb982b7be4..e516a3f842c48 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-copyin-copyout-create.c
@@ -2,12 +2,12 @@
void acc_compute(int parmVar) {
// CHECK: cir.func{{.*}} @acc_compute(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
int localVar1;
- // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} : !cir.ptr<!s32i>
float localVar2;
- // CHECK-NEXT: %[[LV2:.*]] = cir.alloca "localVar2" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[LV2:.*]] = cir.alloca "localVar2" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]]
#pragma acc parallel copyin(parmVar) copyout(localVar1) create(localVar2)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp
index 8801bdf420c68..1eda156f9bac1 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause-templates.cpp
@@ -18,7 +18,7 @@ struct HasDtor {
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
@@ -28,7 +28,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
@@ -38,7 +38,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -52,7 +52,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -64,10 +64,10 @@ struct HasDtor {
template<typename T, typename U, typename V, typename W>
void dependent_version(const T &cc, const U &ndc, const V &dtor, const W &someInt) {
// CHECK: cir.func {{.*}}@_Z17dependent_versionI13CopyConstruct14NonDefaultCtor7HasDtoriEvRKT_RKT0_RKT1_RKT2_(%[[ARG0:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG2:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG3:.*]]: !cir.ptr<!s32i> {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[CC:.*]] = cir.alloca "cc" {{.*}} init const !cir.ptr<!rec_CopyConstruct> -> !cir.ptr<!cir.ptr<!rec_CopyConstruct>>
- // CHECK-NEXT: %[[NDC:.*]] = cir.alloca "ndc" {{.*}} init const !cir.ptr<!rec_NonDefaultCtor> -> !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} init const !cir.ptr<!rec_HasDtor> -> !cir.ptr<!cir.ptr<!rec_HasDtor>>
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[CC:.*]] = cir.alloca "cc" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_CopyConstruct>>
+ // CHECK-NEXT: %[[NDC:.*]] = cir.alloca "ndc" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_HasDtor>>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
#pragma acc parallel firstprivate(cc, ndc, dtor, someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c
index a49819cfc67be..82f8626c3428a 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.c
@@ -4,7 +4,7 @@ struct NoCopyConstruct {};
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -15,7 +15,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.float> {{.*}}):
@@ -26,7 +26,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
@@ -36,7 +36,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -45,7 +45,7 @@ struct NoCopyConstruct {};
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -72,7 +72,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -81,7 +81,7 @@ struct NoCopyConstruct {};
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -108,7 +108,7 @@ struct NoCopyConstruct {};
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -117,7 +117,7 @@ struct NoCopyConstruct {};
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -145,17 +145,17 @@ void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
struct NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
struct NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
#pragma acc parallel firstprivate(someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp
index 0fcbeefc1c473..9d9d7806c09d3 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-firstprivate-clause.cpp
@@ -22,7 +22,7 @@ struct HasDtor {
// CHECK: acc.firstprivate.recipe @firstprivatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!s32i> {{.*}}):
@@ -33,7 +33,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.float> {{.*}}):
@@ -44,7 +44,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
@@ -54,7 +54,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
@@ -64,7 +64,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
@@ -74,7 +74,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -88,7 +88,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -97,7 +97,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -124,7 +124,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -133,7 +133,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -160,7 +160,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -169,7 +169,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -195,7 +195,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -204,7 +204,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -230,7 +230,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -239,7 +239,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -265,7 +265,7 @@ struct HasDtor {
//
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+// CHECK-NEXT: cir.alloca "openacc.firstprivate.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}):
@@ -274,7 +274,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -303,7 +303,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -332,29 +332,29 @@ extern "C" void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} : !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} : !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel firstprivate(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp b/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp
index 415a947c33968..707dff453bf00 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause-templates.cpp
@@ -15,20 +15,20 @@ struct HasDtor {
// CHECK: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor> {{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -38,17 +38,17 @@ struct HasDtor {
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
template<typename T, typename U, typename V, typename W>
void dependent_version(const T &cc, const U &ndc, const V &dtor, const W &someInt) {
// CHECK: cir.func {{.*}}@_Z17dependent_versionI13CopyConstruct14NonDefaultCtor7HasDtoriEvRKT_RKT0_RKT1_RKT2_(%[[ARG0:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}, %[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}, %[[ARG2:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG3:.*]]: !cir.ptr<!s32i> {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[CC:.*]] = cir.alloca "cc" {{.*}} init const !cir.ptr<!rec_CopyConstruct> -> !cir.ptr<!cir.ptr<!rec_CopyConstruct>>
- // CHECK-NEXT: %[[NDC:.*]] = cir.alloca "ndc" {{.*}} init const !cir.ptr<!rec_NonDefaultCtor> -> !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} init const !cir.ptr<!rec_HasDtor> -> !cir.ptr<!cir.ptr<!rec_HasDtor>>
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} init const !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[CC:.*]] = cir.alloca "cc" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_CopyConstruct>>
+ // CHECK-NEXT: %[[NDC:.*]] = cir.alloca "ndc" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_HasDtor>>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
#pragma acc parallel private(cc, ndc, dtor, someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c
index 01d83ac0d03f7..54e27d905c12d 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.c
@@ -5,42 +5,42 @@ struct NoCopyConstruct {};
// int
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// int[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -48,17 +48,17 @@ void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
struct NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
struct NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
#pragma acc parallel private(someInt)
;
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
index 7ea62b5c94973..1f533fa65b96b 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
@@ -17,38 +17,38 @@ struct HasDtor {
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -58,37 +58,37 @@ struct HasDtor {
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -112,7 +112,7 @@ struct HasDtor {
//
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -121,7 +121,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -149,29 +149,29 @@ extern "C" void acc_compute() {
// CHECK: cir.func{{.*}} @acc_compute()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} : !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} : !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc parallel private(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
index d6a8e7eefa576..f38900c55d5e4 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
@@ -23,7 +23,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -70,7 +70,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, {{.*}}, #cir.fp<1{{.*}}> : !cir.double, #true, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -117,7 +117,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, {{.*}}, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -206,7 +206,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, {{.*}}, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -295,7 +295,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!rec_anon_struct1>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true, {{.*}}}> : !rec_anon_struct1
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct1, !cir.ptr<!rec_anon_struct1>
@@ -330,7 +330,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!rec_anon_struct1>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct1
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct1, !cir.ptr<!rec_anon_struct1>
@@ -365,7 +365,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!rec_anon_struct1>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct1
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct1, !cir.ptr<!rec_anon_struct1>
@@ -400,7 +400,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, {{.*}}, #cir.fp<1{{.*}}> : !cir.double, #true, {{.*}}}> : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -488,7 +488,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[ALLOCA]] : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!rec_anon_struct>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_anon_struct
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[BITCAST]] : !rec_anon_struct, !cir.ptr<!rec_anon_struct>
@@ -577,7 +577,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -585,7 +585,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -646,7 +646,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -654,7 +654,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -716,7 +716,7 @@ void acc_compute() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -724,7 +724,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -826,7 +826,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -834,7 +834,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -937,7 +937,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -945,7 +945,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -994,7 +994,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1002,7 +1002,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1051,7 +1051,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1059,7 +1059,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1108,7 +1108,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1116,7 +1116,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1219,7 +1219,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1227,7 +1227,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1331,13 +1331,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1378,7 +1378,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1437,13 +1437,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1484,7 +1484,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1543,13 +1543,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1590,7 +1590,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1695,13 +1695,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1742,7 +1742,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,13 +1847,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1888,7 +1888,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,13 +1935,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1976,7 +1976,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,13 +2023,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2064,7 +2064,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2111,13 +2111,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2158,7 +2158,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2260,13 +2260,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2307,7 +2307,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp
index 2e738b34e2db3..9947c5f69e1dc 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -70,7 +70,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -116,7 +116,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[LEAST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -201,7 +201,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[LARGEST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -286,7 +286,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -320,7 +320,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -354,7 +354,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -388,7 +388,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -472,7 +472,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -557,7 +557,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -565,7 +565,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -626,7 +626,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -634,7 +634,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -696,7 +696,7 @@ void acc_compute() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -704,7 +704,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -803,7 +803,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -811,7 +811,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -910,7 +910,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -918,7 +918,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -967,7 +967,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -975,7 +975,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1024,7 +1024,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1032,7 +1032,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1081,7 +1081,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1089,7 +1089,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1189,7 +1189,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1197,7 +1197,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1298,13 +1298,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1345,7 +1345,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1404,13 +1404,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1451,7 +1451,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1510,13 +1510,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1557,7 +1557,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1658,13 +1658,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1705,7 +1705,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1806,13 +1806,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,7 +1847,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1894,13 +1894,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,7 +1935,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1982,13 +1982,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,7 +2023,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2070,13 +2070,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2117,7 +2117,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2216,13 +2216,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2263,7 +2263,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
index 15d71c69b0e79..ee56c7be02bda 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
@@ -7,7 +7,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -40,7 +40,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -64,7 +64,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -87,7 +87,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -147,7 +147,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -177,7 +177,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -185,7 +185,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -215,7 +215,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -223,7 +223,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -260,7 +260,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -268,7 +268,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -305,7 +305,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -313,7 +313,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -354,7 +354,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -362,7 +362,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -404,13 +404,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -438,7 +438,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -468,13 +468,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -502,7 +502,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -532,13 +532,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -566,7 +566,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -603,13 +603,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -637,7 +637,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -674,13 +674,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -708,7 +708,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -749,13 +749,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -783,7 +783,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp
index b556ea4b69337..0331f8840466f 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp
@@ -8,7 +8,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -146,7 +146,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -176,7 +176,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -184,7 +184,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -214,7 +214,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -222,7 +222,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -259,7 +259,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -267,7 +267,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -304,7 +304,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -312,7 +312,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -352,7 +352,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -360,7 +360,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -401,13 +401,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -435,7 +435,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -465,13 +465,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -499,7 +499,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -529,13 +529,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -563,7 +563,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,13 +600,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -634,7 +634,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -671,13 +671,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -705,7 +705,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -745,13 +745,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -779,7 +779,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp
index 54d3799e18087..ecffce6cbc639 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-inline-ops.cpp
@@ -28,7 +28,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -59,7 +59,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -90,7 +90,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -127,7 +127,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -164,7 +164,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -195,7 +195,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -226,7 +226,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -257,7 +257,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -289,7 +289,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -322,8 +322,8 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -359,7 +359,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -387,7 +387,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -407,7 +407,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -503,7 +503,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -530,7 +530,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -550,7 +550,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -646,7 +646,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -679,7 +679,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -699,7 +699,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -795,7 +795,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -828,7 +828,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -848,7 +848,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -944,7 +944,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -971,7 +971,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -991,8 +991,8 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1029,7 +1029,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1056,7 +1056,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1076,8 +1076,8 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1113,7 +1113,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1140,7 +1140,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1161,7 +1161,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1257,7 +1257,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1287,7 +1287,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1307,8 +1307,8 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1345,7 +1345,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1375,7 +1375,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1396,13 +1396,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1443,7 +1443,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1472,7 +1472,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1499,13 +1499,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1546,7 +1546,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1575,7 +1575,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1602,13 +1602,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1649,7 +1649,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1684,7 +1684,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1711,13 +1711,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1758,7 +1758,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1820,13 +1820,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1867,7 +1867,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1896,7 +1896,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1923,13 +1923,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1970,7 +1970,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1999,7 +1999,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2026,13 +2026,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2073,7 +2073,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2102,7 +2102,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2129,13 +2129,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2176,7 +2176,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2208,7 +2208,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2235,13 +2235,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2282,7 +2282,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2314,7 +2314,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
index 69d370cb57af3..2e63e8ee80922 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
@@ -7,7 +7,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -41,7 +41,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -64,7 +64,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -87,7 +87,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -103,7 +103,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -120,7 +120,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -163,7 +163,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -189,7 +189,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -197,7 +197,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -227,7 +227,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -235,7 +235,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -265,7 +265,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -273,7 +273,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -310,7 +310,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -318,7 +318,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -355,7 +355,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -363,7 +363,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -393,7 +393,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -401,7 +401,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -431,7 +431,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -439,7 +439,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -469,7 +469,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -477,7 +477,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -517,7 +517,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[INIT_VAL:.*]] = cir.const {{.*}} : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[INIT_VAL]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -525,7 +525,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -566,13 +566,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,7 +600,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -630,13 +630,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -664,7 +664,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -694,13 +694,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -728,7 +728,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -765,13 +765,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -799,7 +799,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -836,13 +836,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -870,7 +870,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -900,13 +900,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -934,7 +934,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -964,13 +964,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -998,7 +998,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1028,13 +1028,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1062,7 +1062,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1102,13 +1102,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1136,7 +1136,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp
index 7ccf70372b6c5..b472f604c50c4 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.cpp
@@ -8,7 +8,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -104,7 +104,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -121,7 +121,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -164,7 +164,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARR:.*]] = cir.const #cir.const_array<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARR]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5> loc(#loc12)
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>> loc(#loc12)
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5> loc(#loc12)
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>> loc(#loc12)
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -518,7 +518,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5> loc(#loc12)
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>> loc(#loc12)
// CHECK-NEXT: acc.yield
@@ -526,7 +526,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -567,13 +567,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -601,7 +601,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -631,13 +631,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -665,7 +665,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -695,13 +695,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -729,7 +729,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -766,13 +766,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -800,7 +800,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -837,13 +837,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -871,7 +871,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -901,13 +901,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -935,7 +935,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -965,13 +965,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -999,7 +999,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1029,13 +1029,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1063,7 +1063,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1103,13 +1103,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1137,7 +1137,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp
index 0db0b6f3ecdcf..95864f6173809 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-outline-ops.cpp
@@ -27,7 +27,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -58,7 +58,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -126,7 +126,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -163,7 +163,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -194,7 +194,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -225,7 +225,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -256,7 +256,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -288,7 +288,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -321,8 +321,8 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -358,7 +358,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -386,7 +386,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -406,7 +406,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -502,7 +502,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -529,7 +529,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -549,7 +549,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -645,7 +645,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -678,7 +678,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -698,7 +698,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -794,7 +794,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -827,7 +827,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -847,7 +847,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -943,7 +943,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -970,7 +970,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -990,8 +990,8 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1028,7 +1028,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1055,7 +1055,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1075,8 +1075,8 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1112,7 +1112,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1139,7 +1139,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1160,7 +1160,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1256,7 +1256,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1286,7 +1286,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1306,8 +1306,8 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1344,7 +1344,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1374,7 +1374,7 @@ void acc_compute() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1395,13 +1395,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1442,7 +1442,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1471,7 +1471,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1498,13 +1498,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1545,7 +1545,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1574,7 +1574,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1601,13 +1601,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1648,7 +1648,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1683,7 +1683,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1710,13 +1710,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1757,7 +1757,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1792,7 +1792,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1819,13 +1819,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1866,7 +1866,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1895,7 +1895,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1922,13 +1922,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1969,7 +1969,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1998,7 +1998,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2025,13 +2025,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2072,7 +2072,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2101,7 +2101,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2128,13 +2128,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2175,7 +2175,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2207,7 +2207,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2234,13 +2234,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2281,7 +2281,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2313,7 +2313,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
index 3b890b902217e..44f248c30a1e8 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
@@ -7,7 +7,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSj : !cir.ptr<!u32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -24,7 +24,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSj : !cir.ptr<!u32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -41,7 +41,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSj : !cir.ptr<!u32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -64,7 +64,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSj : !cir.ptr<!u32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -87,7 +87,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSj : !cir.ptr<!u32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -103,7 +103,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSj : !cir.ptr<!u32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -120,7 +120,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSj : !cir.ptr<!u32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -137,7 +137,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSj : !cir.ptr<!u32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -163,7 +163,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSj : !cir.ptr<!u32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!u32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store {{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i, #cir.int<4294967295> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i, #cir.int<1> : !u32i]> : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -519,7 +519,7 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!u32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!u32i x 5>, !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: acc.yield
@@ -527,7 +527,7 @@ void acc_compute() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -569,13 +569,13 @@ void acc_compute() {
#pragma acc parallel reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -603,7 +603,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -633,13 +633,13 @@ void acc_compute() {
#pragma acc parallel reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -667,7 +667,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -697,13 +697,13 @@ void acc_compute() {
#pragma acc parallel reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -731,7 +731,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -768,13 +768,13 @@ void acc_compute() {
#pragma acc parallel reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -802,7 +802,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -839,13 +839,13 @@ void acc_compute() {
#pragma acc parallel reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -873,7 +873,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -903,13 +903,13 @@ void acc_compute() {
#pragma acc parallel reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -937,7 +937,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -967,13 +967,13 @@ void acc_compute() {
#pragma acc parallel reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1001,7 +1001,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1031,13 +1031,13 @@ void acc_compute() {
#pragma acc parallel reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1065,7 +1065,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1106,13 +1106,13 @@ void acc_compute() {
#pragma acc parallel reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_j : !cir.ptr<!cir.array<!u32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!u32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!u32i x 5> -> !cir.ptr<!cir.array<!u32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!u32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1140,7 +1140,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c b/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c
index 9f369890f541e..15ff3d4b181a4 100644
--- a/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c
+++ b/clang/test/CIR/CodeGenOpenACC/data-copy-copyin-copyout-create.c
@@ -2,9 +2,9 @@
void acc_data(int parmVar) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
int localVar1;
- // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[LV1:.*]] = cir.alloca "localVar1" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]]
#pragma acc data copy(parmVar)
diff --git a/clang/test/CIR/CodeGenOpenACC/data.c b/clang/test/CIR/CodeGenOpenACC/data.c
index f2c32f50f4f3e..a11a1b837130e 100644
--- a/clang/test/CIR/CodeGenOpenACC/data.c
+++ b/clang/test/CIR/CodeGenOpenACC/data.c
@@ -2,10 +2,10 @@
void acc_data(int cond) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
int *ptr;
- // CHECK-NEXT: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc data default(none)
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
index a5ae216a938c7..84a1c0c320c36 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copy.cpp
@@ -13,12 +13,12 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca "this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -77,12 +77,12 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca "this"
-// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -147,12 +147,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp
index dffd21ef6b1f9..b772cd454c29b 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copyin.cpp
@@ -260,13 +260,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -324,13 +324,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -395,12 +395,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp b/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp
index 69765e94f7e04..c0a00f134e81f 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-copyout.cpp
@@ -12,13 +12,13 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -76,13 +76,13 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -147,12 +147,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-create.cpp b/clang/test/CIR/CodeGenOpenACC/declare-create.cpp
index 379a4d50425ec..71986f76ea3b2 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-create.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-create.cpp
@@ -262,12 +262,12 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -326,12 +326,12 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -396,12 +396,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
-// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp b/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
index aaed6298c77c3..be33ec508ebc8 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-deviceptr.cpp
@@ -12,11 +12,11 @@ struct Struct {
void MemFunc1(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}}, %[[ARG_INT:.*]]: !cir.ptr<!s32i> {{.*}})
-// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !cir.ptr<!s32i>
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -47,11 +47,11 @@ void use() {
void Struct::MemFunc2(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}}, %[[ARG_INT:.*]]: !cir.ptr<!s32i> {{.*}})
-// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !cir.ptr<!s32i>
+ // CHECK-NEXT: cir.alloca{{.*}}"this"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -88,10 +88,10 @@ extern "C" void do_thing();
void NormalFunc(HasSideEffects *ArgHSE, int *ArgInt) {
// CHECK: cir.func {{.*}}NormalFunc{{.*}}(%[[ARG_HSE:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}}, %[[ARG_INT:.*]]: !cir.ptr<!s32i> {{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !cir.ptr<!s32i>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt"
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
HasSideEffects *LocalHSE;
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp b/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp
index 7c286fc7579a0..0a1759cb20c39 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-deviceresident.cpp
@@ -261,12 +261,12 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -325,12 +325,12 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -395,12 +395,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/declare-present.cpp b/clang/test/CIR/CodeGenOpenACC/declare-present.cpp
index 30996cadcdd09..75ddd1400a6d4 100644
--- a/clang/test/CIR/CodeGenOpenACC/declare-present.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/declare-present.cpp
@@ -14,12 +14,12 @@ struct Struct {
void MemFunc1(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc1{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca "this"
-// CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -78,12 +78,12 @@ void use() {
void Struct::MemFunc2(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}MemFunc2{{.*}}(%{{.*}}: !cir.ptr<!rec_Struct>{{.*}}, %[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
// CHECK-NEXT: cir.alloca{{.*}}"this"
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
@@ -148,12 +148,12 @@ extern "C" void do_thing();
extern "C" void NormalFunc(HasSideEffects ArgHSE, int ArgInt, HasSideEffects *ArgHSEPtr) {
// CHECK: cir.func {{.*}}NormalFunc(%[[ARG_HSE:.*]]: !rec_HasSideEffects{{.*}}, %[[ARG_INT:.*]]: !s32i {{.*}}, %[[ARG_HSE_PTR:.*]]: !cir.ptr<!rec_HasSideEffects>{{.*}})
- // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} !s32i
- // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} !cir.ptr<!rec_HasSideEffects>
- // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} !rec_HasSideEffects
- // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} !cir.array<!rec_HasSideEffects x 5>
- // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} !s32i
+ // CHECK-NEXT: %[[ARG_HSE_ALLOCA:.*]] = cir.alloca "ArgHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[ARG_INT_ALLOCA:.*]] = cir.alloca "ArgInt" {{.*}} : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARG_HSE_PTR_ALLOCA:.*]] = cir.alloca "ArgHSEPtr" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasSideEffects>>
+ // CHECK-NEXT: %[[LOC_HSE_ALLOCA:.*]] = cir.alloca "LocalHSE" {{.*}} : !cir.ptr<!rec_HasSideEffects>
+ // CHECK-NEXT: %[[LOC_HSE_ARR_ALLOCA:.*]] = cir.alloca "LocalHSEArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasSideEffects x 5>>
+ // CHECK-NEXT: %[[LOC_INT_ALLOCA:.*]] = cir.alloca "LocalInt" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.store
diff --git a/clang/test/CIR/CodeGenOpenACC/enter-data.c b/clang/test/CIR/CodeGenOpenACC/enter-data.c
index 41b43ed9ee70c..d7a47bae35da3 100644
--- a/clang/test/CIR/CodeGenOpenACC/enter-data.c
+++ b/clang/test/CIR/CodeGenOpenACC/enter-data.c
@@ -1,8 +1,8 @@
// RUN: %clang_cc1 -fopenacc -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir %s -o - | FileCheck %s
void acc_data(int parmVar, int *ptrParmVar) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}, %[[PTRARG:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[PTRARG]], %[[PTRPARM]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/exit-data.c b/clang/test/CIR/CodeGenOpenACC/exit-data.c
index 05c6141529ea7..74bdf4c959481 100644
--- a/clang/test/CIR/CodeGenOpenACC/exit-data.c
+++ b/clang/test/CIR/CodeGenOpenACC/exit-data.c
@@ -1,8 +1,8 @@
// RUN: %clang_cc1 -fopenacc -Wno-openacc-self-if-potential-conflict -emit-cir -fclangir %s -o - | FileCheck %s
void acc_data(int parmVar, int *ptrParmVar) {
// CHECK: cir.func{{.*}} @acc_data(%[[ARG:.*]]: !s32i{{.*}}, %[[PTRARG:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[PTRARG]], %[[PTRPARM]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp b/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp
index b56302e1750a0..8a9163182d21d 100644
--- a/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/firstprivate-clause-recipes.cpp
@@ -20,7 +20,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel firstprivate(ThreeArr[B][B][B])
// CHECK:acc.firstprivate.recipe @firstprivatization__Bcnt3__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } copy {
// CHECK-NEXT: ^bb0(%[[ARG_FROM:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[ARG_TO:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -29,7 +29,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -46,7 +46,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -63,7 +63,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -108,7 +108,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB3_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -125,7 +125,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -142,7 +142,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -187,15 +187,15 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel firstprivate(ThreePtr[B][B][A:B])
// CHECK: acc.firstprivate.recipe @firstprivatization__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -225,12 +225,12 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -259,11 +259,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -295,7 +295,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -313,7 +313,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -330,7 +330,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -376,7 +376,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -394,7 +394,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -411,7 +411,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -458,15 +458,15 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel firstprivate(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.firstprivate.recipe @firstprivatization__Bcnt3__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.firstprivate.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -502,10 +502,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -534,7 +534,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -551,7 +551,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -568,7 +568,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -613,7 +613,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -631,7 +631,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -648,7 +648,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/host_data.c b/clang/test/CIR/CodeGenOpenACC/host_data.c
index dd0fdbffa51e9..4e2dcf4a52db4 100644
--- a/clang/test/CIR/CodeGenOpenACC/host_data.c
+++ b/clang/test/CIR/CodeGenOpenACC/host_data.c
@@ -2,10 +2,10 @@
void acc_host_data(int cond, int var1, int var2, int *arr) {
// CHECK: cir.func{{.*}} @acc_host_data(%[[ARG_COND:.*]]: !s32i {{.*}}, %[[ARG_V1:.*]]: !s32i {{.*}}, %[[ARG_V2:.*]]: !s32i {{.*}}, %[[ARG_ARR:.*]]: !cir.ptr<!s32i> {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[V1:.*]] = cir.alloca "var1" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[V2:.*]] = cir.alloca "var2" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[V1:.*]] = cir.alloca "var1" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[V2:.*]] = cir.alloca "var2" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ARR:.*]] = cir.alloca "arr" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG_COND]], %[[COND]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_V1]], %[[V1]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_V2]], %[[V2]] : !s32i, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenACC/init.c b/clang/test/CIR/CodeGenOpenACC/init.c
index fad0009af08f7..4c1d74abfbdfe 100644
--- a/clang/test/CIR/CodeGenOpenACC/init.c
+++ b/clang/test/CIR/CodeGenOpenACC/init.c
@@ -2,7 +2,7 @@
void acc_init(int cond) {
// CHECK: cir.func{{.*}} @acc_init(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc init
// CHECK-NEXT: acc.init loc(#{{[a-zA-Z0-9]+}}){{$}}
diff --git a/clang/test/CIR/CodeGenOpenACC/kernels.c b/clang/test/CIR/CodeGenOpenACC/kernels.c
index f85d5308576ff..1602dbb65b153 100644
--- a/clang/test/CIR/CodeGenOpenACC/kernels.c
+++ b/clang/test/CIR/CodeGenOpenACC/kernels.c
@@ -2,7 +2,7 @@
void acc_kernels(int cond) {
// CHECK: cir.func{{.*}} @acc_kernels(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc kernels
{}
@@ -419,8 +419,8 @@ void acc_kernels(int cond) {
void acc_kernels_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_kernels_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp b/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
index 816b22e5e869e..d695382ef05bd 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
@@ -18,35 +18,35 @@ struct HasDtor {
// int
// CHECK: acc.private.recipe @privatization__ZTSi : !cir.ptr<!s32i> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float
// CHECK-NEXT: acc.private.recipe @privatization__ZTSf : !cir.ptr<!cir.float> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS15NoCopyConstruct : !cir.ptr<!rec_NoCopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NoCopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct
// CHECK-NEXT: acc.private.recipe @privatization__ZTS13CopyConstruct : !cir.ptr<!rec_CopyConstruct> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_CopyConstruct> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_CopyConstruct>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS14NonDefaultCtor : !cir.ptr<!rec_NonDefaultCtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ALLOCA]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
@@ -54,7 +54,7 @@ struct HasDtor {
// HasDtor
// CHECK-NEXT: acc.private.recipe @privatization__ZTS7HasDtor : !cir.ptr<!rec_HasDtor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!rec_HasDtor>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}, %[[ARG:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
@@ -65,41 +65,41 @@ struct HasDtor {
// int[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// float[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NoCopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_15NoCopyConstruct : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CopyConstruct[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_13CopyConstruct : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CopyConstruct x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// NonDefaultCtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_14NonDefaultCtor : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -124,7 +124,7 @@ struct HasDtor {
// HasDtor[5] with 1 'bound'
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSA5_7HasDtor : !cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
// CHECK-NEXT: ^bb0(%[[ORIG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
@@ -133,7 +133,7 @@ struct HasDtor {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -161,29 +161,29 @@ extern "C" void acc_loop() {
// CHECK: cir.func{{.*}} @acc_loop()
int someInt;
- // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[SOMEINT:.*]] = cir.alloca "someInt" {{.*}} : !cir.ptr<!s32i>
float someFloat;
- // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} !cir.float -> !cir.ptr<!cir.float>
+ // CHECK-NEXT: %[[SOMEFLOAT:.*]] = cir.alloca "someFloat" {{.*}} : !cir.ptr<!cir.float>
NoCopyConstruct noCopy;
- // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} !rec_NoCopyConstruct -> !cir.ptr<!rec_NoCopyConstruct>
+ // CHECK-NEXT: %[[NOCOPY:.*]] = cir.alloca "noCopy" {{.*}} : !cir.ptr<!rec_NoCopyConstruct>
CopyConstruct hasCopy;
- // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} !rec_CopyConstruct -> !cir.ptr<!rec_CopyConstruct>
+ // CHECK-NEXT: %[[HASCOPY:.*]] = cir.alloca "hasCopy" {{.*}} : !cir.ptr<!rec_CopyConstruct>
NonDefaultCtor notDefCtor;
- // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init !rec_NonDefaultCtor -> !cir.ptr<!rec_NonDefaultCtor>
+ // CHECK-NEXT: %[[NOTDEFCTOR:.*]] = cir.alloca "notDefCtor" {{.*}} init : !cir.ptr<!rec_NonDefaultCtor>
HasDtor dtor;
- // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} !rec_HasDtor -> !cir.ptr<!rec_HasDtor>
+ // CHECK-NEXT: %[[DTOR:.*]] = cir.alloca "dtor" {{.*}} : !cir.ptr<!rec_HasDtor>
int someIntArr[5];
- // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+ // CHECK-NEXT: %[[INTARR:.*]] = cir.alloca "someIntArr" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
float someFloatArr[5];
- // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+ // CHECK-NEXT: %[[FLOATARR:.*]] = cir.alloca "someFloatArr" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
NoCopyConstruct noCopyArr[5];
- // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} !cir.array<!rec_NoCopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
+ // CHECK-NEXT: %[[NOCOPYARR:.*]] = cir.alloca "noCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_NoCopyConstruct x 5>>
CopyConstruct hasCopyArr[5];
- // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} !cir.array<!rec_CopyConstruct x 5> -> !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
+ // CHECK-NEXT: %[[HASCOPYARR:.*]] = cir.alloca "hasCopyArr" {{.*}} : !cir.ptr<!cir.array<!rec_CopyConstruct x 5>>
NonDefaultCtor notDefCtorArr[5];
- // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init !cir.array<!rec_NonDefaultCtor x 5> -> !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
+ // CHECK-NEXT: %[[NOTDEFCTORARR:.*]] = cir.alloca "notDefCtorArr" {{.*}} init : !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
HasDtor dtorArr[5];
- // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} !cir.array<!rec_HasDtor x 5> -> !cir.ptr<!cir.array<!rec_HasDtor x 5>>
+ // CHECK-NEXT: %[[DTORARR:.*]] = cir.alloca "dtorArr" {{.*}} : !cir.ptr<!cir.array<!rec_HasDtor x 5>>
// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[NOTDEFCTOR]]) : (!cir.ptr<!rec_NonDefaultCtor>{{.*}}) -> ()
#pragma acc loop private(someInt)
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp
index f10b2afbca002..dd3806587d269 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp
@@ -24,7 +24,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -70,7 +70,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -116,7 +116,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -201,7 +201,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -286,7 +286,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -320,7 +320,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -354,7 +354,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperatorsNoFloats -> !cir.ptr<!rec_DefaultOperatorsNoFloats>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>
// CHECK-NEXT: acc.yield
@@ -388,7 +388,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -472,7 +472,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_DefaultOperators -> !cir.ptr<!rec_DefaultOperators>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: acc.yield
@@ -557,7 +557,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -565,7 +565,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -626,7 +626,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -634,7 +634,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -696,7 +696,7 @@ void acc_loop() {
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<-2147483648> : !s32i, #cir.int<0> : !u32i, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-1.7{{.*}}E+308> : !cir.double, #false}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -704,7 +704,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -803,7 +803,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<2147483647> : !s32i, #cir.int<4294967295> : !u32i, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<1.7{{.*}}E+308> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -811,7 +811,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -910,7 +910,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats, #cir.const_record<{#cir.int<-1> : !s32i, #cir.int<4294967295> : !u32i, #true}> : !rec_DefaultOperatorsNoFloats]> : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -918,7 +918,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -967,7 +967,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -975,7 +975,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1024,7 +1024,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArrNoFloats)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperatorsNoFloats x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: acc.yield
@@ -1032,7 +1032,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1081,7 +1081,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.const_array<[#cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators, #cir.const_record<{#cir.int<1> : !s32i, #cir.int<1> : !u32i, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.double, #true}> : !rec_DefaultOperators]> : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1089,7 +1089,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1189,7 +1189,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!rec_DefaultOperators x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: acc.yield
@@ -1197,7 +1197,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1298,13 +1298,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1345,7 +1345,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1404,13 +1404,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1451,7 +1451,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1510,13 +1510,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1557,7 +1557,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1658,13 +1658,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1705,7 +1705,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1806,13 +1806,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1847,7 +1847,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1894,13 +1894,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1935,7 +1935,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1982,13 +1982,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArrNoFloats[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperatorsNoFloats x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2023,7 +2023,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2070,13 +2070,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2117,7 +2117,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2216,13 +2216,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_DefaultOperators x 5> -> !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2263,7 +2263,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp
index 6a2ba138e6246..5e49a2e0e37df 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp
@@ -8,7 +8,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSf : !cir.ptr<!cir.float> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSf : !cir.ptr<!cir.float> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSf : !cir.ptr<!cir.float> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.fp<-3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSf : !cir.ptr<!cir.float> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.fp<3.4{{.*}}E+38> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.fp<1{{.*}}> : !cir.float
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -112,7 +112,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSf : !cir.ptr<!cir.float> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.float -> !cir.ptr<!cir.float>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: acc.yield
@@ -138,7 +138,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -146,7 +146,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -176,7 +176,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -184,7 +184,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -214,7 +214,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float, #cir.fp<-3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -222,7 +222,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -259,7 +259,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float, #cir.fp<3.4{{.*}}E+38> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -267,7 +267,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -304,7 +304,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float, #cir.fp<1{{.*}}> : !cir.float]> : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -312,7 +312,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -352,7 +352,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!cir.float x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: acc.yield
@@ -360,7 +360,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -401,13 +401,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -435,7 +435,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -465,13 +465,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -499,7 +499,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -529,13 +529,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -563,7 +563,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -600,13 +600,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -634,7 +634,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -671,13 +671,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -705,7 +705,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -745,13 +745,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!cir.float x 5> -> !cir.ptr<!cir.array<!cir.float x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!cir.float x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -779,7 +779,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp
index 95e593bd485f9..e7cdb7693c0dd 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-inline-ops.cpp
@@ -28,7 +28,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -59,7 +59,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -90,7 +90,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -127,7 +127,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -164,7 +164,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -195,7 +195,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -226,7 +226,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -257,7 +257,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -289,7 +289,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS18HasOperatorsInline : !cir.ptr<!rec_HasOperatorsInline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsInline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsInline -> !cir.ptr<!rec_HasOperatorsInline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -322,8 +322,8 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -359,7 +359,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -387,7 +387,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -407,7 +407,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -503,7 +503,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -530,7 +530,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -550,7 +550,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -646,7 +646,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -679,7 +679,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -699,7 +699,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -795,7 +795,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -828,7 +828,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -848,7 +848,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -944,7 +944,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -971,7 +971,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -991,8 +991,8 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1029,7 +1029,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1056,7 +1056,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1076,8 +1076,8 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1113,7 +1113,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1140,7 +1140,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1161,7 +1161,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1257,7 +1257,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1287,7 +1287,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1307,8 +1307,8 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1345,7 +1345,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1375,7 +1375,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> -> !cir.ptr<!rec_HasOperatorsInline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsInline>, !u64i) -> !cir.ptr<!rec_HasOperatorsInline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsInline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsInline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsInline>>, !cir.ptr<!rec_HasOperatorsInline>
@@ -1396,13 +1396,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1443,7 +1443,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1472,7 +1472,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1499,13 +1499,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1546,7 +1546,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1575,7 +1575,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1602,13 +1602,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1649,7 +1649,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1684,7 +1684,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1711,13 +1711,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1758,7 +1758,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1820,13 +1820,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1867,7 +1867,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1896,7 +1896,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1923,13 +1923,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1970,7 +1970,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1999,7 +1999,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2026,13 +2026,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2073,7 +2073,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2102,7 +2102,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2129,13 +2129,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2176,7 +2176,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2208,7 +2208,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2235,13 +2235,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_18HasOperatorsInline : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsInline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsInline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2282,7 +2282,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2314,7 +2314,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp
index 5d1494efafd9c..beb667faaf769 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-int.cpp
@@ -8,7 +8,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTSi : !cir.ptr<!s32i> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -25,7 +25,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSi : !cir.ptr<!s32i> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -42,7 +42,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSi : !cir.ptr<!s32i> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -65,7 +65,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSi : !cir.ptr<!s32i> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -88,7 +88,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSi : !cir.ptr<!s32i> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -104,7 +104,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSi : !cir.ptr<!s32i> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -121,7 +121,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSi : !cir.ptr<!s32i> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -139,7 +139,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSi : !cir.ptr<!s32i> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store{{.*}} %[[ONE]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -164,7 +164,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSi : !cir.ptr<!s32i> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!s32i>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: acc.yield
@@ -190,7 +190,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_add__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -198,7 +198,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -228,7 +228,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -236,7 +236,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -266,7 +266,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i, #cir.int<-2147483648> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -274,7 +274,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -311,7 +311,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i, #cir.int<2147483647> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -319,7 +319,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" {{.*}} : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -356,7 +356,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -364,7 +364,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -394,7 +394,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -402,7 +402,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -432,7 +432,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -440,7 +440,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -470,7 +470,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[CONST_ARRAY:.*]] = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[CONST_ARRAY]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -478,7 +478,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -518,7 +518,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !cir.array<!s32i x 5>
// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.array<!s32i x 5>, !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
@@ -526,7 +526,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -567,13 +567,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -601,7 +601,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -631,13 +631,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -665,7 +665,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -695,13 +695,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -729,7 +729,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -766,13 +766,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -800,7 +800,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" {{.*}} : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -837,13 +837,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -871,7 +871,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -901,13 +901,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -935,7 +935,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -965,13 +965,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -999,7 +999,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1029,13 +1029,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1063,7 +1063,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1103,13 +1103,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!s32i x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1137,7 +1137,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp
index 61f13150a1180..41bb299bf6267 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-outline-ops.cpp
@@ -27,7 +27,7 @@ void acc_loop() {
#pragma acc loop reduction(+:someVar)
// CHECK: acc.reduction.recipe @reduction_add__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -58,7 +58,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVar)
// CHECK: acc.reduction.recipe @reduction_mul__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -89,7 +89,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVar)
// CHECK: acc.reduction.recipe @reduction_max__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LEAST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -126,7 +126,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVar)
// CHECK: acc.reduction.recipe @reduction_min__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[LARGEST]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -163,7 +163,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVar)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -194,7 +194,7 @@ void acc_loop() {
#pragma acc loop reduction(|:someVar)
// CHECK: acc.reduction.recipe @reduction_ior__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -225,7 +225,7 @@ void acc_loop() {
#pragma acc loop reduction(^:someVar)
// CHECK: acc.reduction.recipe @reduction_xor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -256,7 +256,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVar)
// CHECK: acc.reduction.recipe @reduction_land__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ONE]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -288,7 +288,7 @@ void acc_loop() {
#pragma acc loop reduction(||:someVar)
// CHECK: acc.reduction.recipe @reduction_lor__ZTS19HasOperatorsOutline : !cir.ptr<!rec_HasOperatorsOutline> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_HasOperatorsOutline>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !rec_HasOperatorsOutline -> !cir.ptr<!rec_HasOperatorsOutline>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i>
@@ -321,8 +321,8 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr)
// CHECK: acc.reduction.recipe @reduction_add__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -358,7 +358,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -386,7 +386,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -406,7 +406,7 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -502,7 +502,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -529,7 +529,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -549,7 +549,7 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_max__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LEAST:.*]] = cir.const #cir.int<-2147483648> : !s32i
@@ -645,7 +645,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -678,7 +678,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -698,7 +698,7 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_min__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[LARGEST:.*]] = cir.const #cir.int<2147483647> : !s32i
@@ -794,7 +794,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -827,7 +827,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -847,7 +847,7 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i
@@ -943,7 +943,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -970,7 +970,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -990,8 +990,8 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1028,7 +1028,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1055,7 +1055,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1075,8 +1075,8 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1112,7 +1112,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1139,7 +1139,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1160,7 +1160,7 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr)
// CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!s32i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
@@ -1256,7 +1256,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1286,7 +1286,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1306,8 +1306,8 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr)
// CHECK: acc.reduction.recipe @reduction_lor__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}})
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
-// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} init : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca "arrayinit.temp" {{.*}} : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i
@@ -1344,7 +1344,7 @@ void acc_loop() {
// CHECK-NEXT: } combiner {
// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> {{.*}})
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!s64i>
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !s64i, !cir.ptr<!s64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!s64i>, !s64i
@@ -1374,7 +1374,7 @@ void acc_loop() {
// CHECK-NEXT: %[[SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ARG]] : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> -> !cir.ptr<!rec_HasOperatorsOutline>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[SIZE]] : (!cir.ptr<!rec_HasOperatorsOutline>, !u64i) -> !cir.ptr<!rec_HasOperatorsOutline>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_HasOperatorsOutline> -> !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[IDX]] : !cir.ptr<!rec_HasOperatorsOutline>, !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[CUR:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_HasOperatorsOutline>>, !cir.ptr<!rec_HasOperatorsOutline>
@@ -1395,13 +1395,13 @@ void acc_loop() {
#pragma acc loop reduction(+:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_add__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1442,7 +1442,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1471,7 +1471,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1498,13 +1498,13 @@ void acc_loop() {
#pragma acc loop reduction(*:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_mul__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1545,7 +1545,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1574,7 +1574,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1601,13 +1601,13 @@ void acc_loop() {
#pragma acc loop reduction(max:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_max__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <max> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1648,7 +1648,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1683,7 +1683,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1710,13 +1710,13 @@ void acc_loop() {
#pragma acc loop reduction(min:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_min__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <min> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1757,7 +1757,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1792,7 +1792,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1819,13 +1819,13 @@ void acc_loop() {
#pragma acc loop reduction(&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <iand> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1866,7 +1866,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1895,7 +1895,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -1922,13 +1922,13 @@ void acc_loop() {
#pragma acc loop reduction(|:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <ior> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1969,7 +1969,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -1998,7 +1998,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2025,13 +2025,13 @@ void acc_loop() {
#pragma acc loop reduction(^:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <xor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2072,7 +2072,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2101,7 +2101,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2128,13 +2128,13 @@ void acc_loop() {
#pragma acc loop reduction(&&:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <land> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2175,7 +2175,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2207,7 +2207,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
@@ -2234,13 +2234,13 @@ void acc_loop() {
#pragma acc loop reduction(||:someVarArr[2])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt1__ZTSA5_19HasOperatorsOutline : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}}))
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} !cir.array<!rec_HasOperatorsOutline x 5> -> !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca "openacc.reduction.init" {{.*}} : !cir.ptr<!cir.array<!rec_HasOperatorsOutline x 5>>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2281,7 +2281,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -2313,7 +2313,7 @@ void acc_loop() {
// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i
// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/loop.cpp b/clang/test/CIR/CodeGenOpenACC/loop.cpp
index ca8a48f73b6ca..8c2589d6d00d2 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop.cpp
@@ -2,10 +2,10 @@
extern "C" void acc_loop(int *A, int *B, int *C, int N) {
// CHECK: cir.func{{.*}} @acc_loop(%[[ARG_A:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_B:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_C:.*]]: !cir.ptr<!s32i> {{.*}}, %[[ARG_N:.*]]: !s32i {{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ALLOCA_A:.*]] = cir.alloca "A" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ALLOCA_B:.*]] = cir.alloca "B" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ALLOCA_C:.*]] = cir.alloca "C" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca "N" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[ALLOCA_A:.*]] = cir.alloca "A" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ALLOCA_B:.*]] = cir.alloca "B" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ALLOCA_C:.*]] = cir.alloca "C" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ALLOCA_N:.*]] = cir.alloca "N" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG_A]], %[[ALLOCA_A]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG_B]], %[[ALLOCA_B]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG_C]], %[[ALLOCA_C]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/parallel.c b/clang/test/CIR/CodeGenOpenACC/parallel.c
index f00bd89ff358e..663d16fbba8f1 100644
--- a/clang/test/CIR/CodeGenOpenACC/parallel.c
+++ b/clang/test/CIR/CodeGenOpenACC/parallel.c
@@ -2,7 +2,7 @@
void acc_parallel(int cond) {
// CHECK: cir.func{{.*}} @acc_parallel(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc parallel
{}
@@ -446,8 +446,8 @@ void acc_parallel(int cond) {
void acc_parallel_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_parallel_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp
index 5b884a01a538f..a1682e80a2fd1 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-CtorDtor.cpp
@@ -13,7 +13,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_8CtorDtor : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CtorDtor x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// Init Section.
// CHECK-NEXT: cir.scope {
@@ -21,7 +21,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -49,7 +49,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -79,11 +79,11 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_8CtorDtor : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_CtorDtor x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init : !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -103,7 +103,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[PRIVATE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -125,14 +125,14 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!rec_CtorDtor x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>
// Init Section:
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB2:.*]] = acc.get_lowerbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -149,7 +149,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -185,7 +185,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -204,7 +204,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -244,12 +244,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!rec_CtorDtor x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5>> -> !cir.ptr<!cir.array<!rec_CtorDtor x 25>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<25> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 25>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -270,7 +270,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<25> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 25>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -292,7 +292,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B][B])
// CHECK-NEXT:acc.private.recipe @privatization__Bcnt3__ZTSA5_A5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -300,7 +300,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -315,7 +315,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -330,7 +330,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -373,7 +373,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB3_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -390,7 +390,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -407,7 +407,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -456,14 +456,14 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
// Init Section:
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB2:.*]] = acc.get_lowerbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -480,7 +480,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -494,7 +494,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[ARR_DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[ARR_DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -532,7 +532,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -551,7 +551,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -567,7 +567,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[ARR_DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -607,12 +607,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_A5_8CtorDtor : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_CtorDtor x 5> x 5> x 5>> -> !cir.ptr<!cir.array<!rec_CtorDtor x 125>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<125> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 125>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -633,7 +633,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<125> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_CtorDtor x 125>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[LAST_ELT]], %[[ARR_IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp
index c721467bf5338..ed66265318c9c 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-NoOps.cpp
@@ -8,7 +8,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_5NoOps : !cir.ptr<!cir.array<!rec_NoOps x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_NoOps x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// Init Section.
// CHECK-NEXT: cir.scope {
@@ -16,7 +16,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -44,11 +44,11 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_5NoOps : !cir.ptr<!cir.array<!rec_NoOps x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_NoOps x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init : !cir.ptr<!cir.array<!rec_NoOps x 5>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -70,7 +70,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!rec_NoOps x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -78,7 +78,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -95,7 +95,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -133,12 +133,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!rec_NoOps x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!rec_NoOps x 5> x 5>> -> !cir.ptr<!cir.array<!rec_NoOps x 25>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<25> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_NoOps x 25>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -160,7 +160,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B][B])
// CHECK-NEXT:acc.private.recipe @privatization__Bcnt3__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -168,7 +168,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -183,7 +183,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -198,7 +198,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -245,14 +245,14 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
// Init Section:
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[LB2:.*]] = acc.get_lowerbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -269,7 +269,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -283,7 +283,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[ARR_DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[LAST_ELT:.*]] = cir.ptr_stride %[[ARR_DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[ARR_DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -323,12 +323,12 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(16) init : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
// CHECK-NEXT: %[[BITCAST:.*]] = cir.cast bitcast %[[TL_ALLOCA]] : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> -> !cir.ptr<!cir.array<!rec_NoOps x 125>>
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<125> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[BITCAST]] : !cir.ptr<!cir.array<!rec_NoOps x 125>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ONE_PAST_LAST_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[ARR_IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[ARR_IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp
index 5bd94c130b43f..abda9b40bf271 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-array-recipes-int.cpp
@@ -6,7 +6,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -15,7 +15,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OneArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_i : !cir.ptr<!cir.array<!s32i x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!s32i x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!s32i x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -24,7 +24,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr[A:B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_i : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!s32i x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -35,7 +35,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_i : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.array<!s32i x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.array<!s32i x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -44,7 +44,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B][B])
// CHECK-NEXT:acc.private.recipe @privatization__Bcnt3__ZTSA5_A5_A5_i : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -57,7 +57,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_A5_A5_i : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -68,7 +68,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreeArr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_A5_A5_i : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.array<!cir.array<!s32i x 5> x 5> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp
index bd904b20a836e..6f2452c84282b 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-CtorDtor.cpp
@@ -13,16 +13,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB1_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -51,7 +51,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -79,7 +79,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -110,7 +110,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK: acc.private.recipe @privatization__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -119,16 +119,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -156,10 +156,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -187,7 +187,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -202,7 +202,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -237,7 +237,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -254,7 +254,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -293,7 +293,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -302,16 +302,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -339,10 +339,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -369,10 +369,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -401,7 +401,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -416,7 +416,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -431,7 +431,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -474,7 +474,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -492,7 +492,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -509,7 +509,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -558,16 +558,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -595,10 +595,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -629,7 +629,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -639,7 +639,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr[B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_P8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -653,10 +653,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -685,7 +685,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -700,7 +700,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -736,7 +736,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -753,7 +753,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -792,7 +792,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_P8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -802,16 +802,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -840,7 +840,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -855,7 +855,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -890,7 +890,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -907,7 +907,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -946,7 +946,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -955,7 +955,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSA5_PP8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
@@ -969,10 +969,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -999,10 +999,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1030,7 +1030,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1045,7 +1045,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1060,7 +1060,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1103,7 +1103,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -1121,7 +1121,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1138,7 +1138,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1187,7 +1187,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_PP8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -1201,10 +1201,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1235,7 +1235,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_PP8CtorDtor : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_CtorDtor>> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -1244,16 +1244,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1281,10 +1281,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1312,7 +1312,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1327,7 +1327,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1342,7 +1342,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1385,7 +1385,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -1403,7 +1403,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1420,7 +1420,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1469,16 +1469,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1505,10 +1505,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_CtorDtor x 5> -> !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!rec_CtorDtor x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1536,7 +1536,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1551,7 +1551,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1564,7 +1564,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -1602,7 +1602,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1621,7 +1621,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1637,7 +1637,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_CtorDtor x 5>> -> !cir.ptr<!rec_CtorDtor>
// CHECK-NEXT: %[[ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_CtorDtor>, !u64i) -> !cir.ptr<!rec_CtorDtor>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.store %[[ELT]], %[[IDX]] : !cir.ptr<!rec_CtorDtor>, !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_CtorDtor>>, !cir.ptr<!rec_CtorDtor>
@@ -1677,7 +1677,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPA5_8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_CtorDtor x 5>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -1688,16 +1688,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1733,10 +1733,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1763,7 +1763,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1778,7 +1778,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1793,7 +1793,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1836,7 +1836,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -1854,7 +1854,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -1871,7 +1871,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -1920,16 +1920,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_CtorDtor> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1961,7 +1961,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_P8CtorDtor : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_CtorDtor> x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp
index f1bff4cb1f02e..ccc2ebeda3ade 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-NoOps.cpp
@@ -8,16 +8,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB1_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -46,7 +46,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -74,7 +74,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK: acc.private.recipe @privatization__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -83,16 +83,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -120,10 +120,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -150,7 +150,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -165,7 +165,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -202,7 +202,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -211,16 +211,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -248,10 +248,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -278,10 +278,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -309,7 +309,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -324,7 +324,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -339,7 +339,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -386,16 +386,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -423,10 +423,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -457,7 +457,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -467,7 +467,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr[B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_P5NoOps : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -481,10 +481,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -512,7 +512,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -527,7 +527,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -565,7 +565,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_P5NoOps : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -576,16 +576,16 @@ void do_things(unsigned A, unsigned B) {
;
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -613,7 +613,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -628,7 +628,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -664,7 +664,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -673,7 +673,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSA5_PP5NoOps : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
@@ -687,10 +687,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -717,10 +717,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -747,7 +747,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -762,7 +762,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -777,7 +777,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -824,7 +824,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_PP5NoOps : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -838,10 +838,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -872,7 +872,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_PP5NoOps : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!rec_NoOps>> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -881,16 +881,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -918,10 +918,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -948,7 +948,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -963,7 +963,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -978,7 +978,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1025,16 +1025,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1062,10 +1062,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!rec_NoOps x 5> -> !cir.ptr<!cir.array<!rec_NoOps x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!rec_NoOps x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1092,7 +1092,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1107,7 +1107,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1120,7 +1120,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<5> : !u64i
// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[STRIDE]] : !cir.ptr<!cir.array<!rec_NoOps x 5>> -> !cir.ptr<!rec_NoOps>
// CHECK-NEXT: %[[ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ARR_SIZE]] : (!cir.ptr<!rec_NoOps>, !u64i) -> !cir.ptr<!rec_NoOps>
-// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[IDX:.*]] = cir.alloca "__array_idx" align(1) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.store %[[DECAY]], %[[IDX]] : !cir.ptr<!rec_NoOps>, !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: cir.do {
// CHECK-NEXT: %[[IDX_LOAD:.*]] = cir.load %[[IDX]] : !cir.ptr<!cir.ptr<!rec_NoOps>>, !cir.ptr<!rec_NoOps>
@@ -1160,7 +1160,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPA5_5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!rec_NoOps x 5>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -1171,16 +1171,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1216,10 +1216,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1246,7 +1246,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -1261,7 +1261,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -1276,7 +1276,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -1323,16 +1323,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -1364,7 +1364,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp
index c9ba81735fb71..5211e79e17f51 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-array-recipes-int.cpp
@@ -6,16 +6,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr[A:B])
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!s32i>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB1_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -46,7 +46,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.ptr<!s32i>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -55,16 +55,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -92,10 +92,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -126,7 +126,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -135,16 +135,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -172,10 +172,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -201,10 +201,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ARR_ALLOCA3:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -237,16 +237,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -274,10 +274,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -308,7 +308,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -318,7 +318,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr[B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_Pi : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
//
@@ -331,10 +331,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -365,7 +365,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_Pi : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -375,16 +375,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_i : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!s32i x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -416,7 +416,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrToArrays)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPA5_i : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -425,7 +425,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSA5_PPi : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
@@ -439,10 +439,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -469,10 +469,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -505,7 +505,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSA5_PPi : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
@@ -519,10 +519,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -553,7 +553,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ArrayOfPtrPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_PPi : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) !cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(16) : !cir.ptr<!cir.array<!cir.ptr<!cir.ptr<!s32i>> x 5>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -562,16 +562,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPA5_i : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -600,10 +600,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB2_CAST]], %[[UB3_CAST]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!s32i x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -636,16 +636,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPA5_i : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.array<!s32i x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -673,10 +673,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UB1_CAST]], %[[UB2_CAST]] : !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<20> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!s32i x 5> -> !cir.ptr<!cir.array<!s32i x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!s32i x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -707,7 +707,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrPtrToArray)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPA5_i : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.array<!s32i x 5>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
@@ -718,16 +718,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPA5_Pi : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -763,10 +763,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -800,16 +800,16 @@ void do_things(unsigned A, unsigned B) {
// #pragma acc parallel private(PtrArrayPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPA5_Pi : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
//
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB2_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!s32i> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -841,7 +841,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(PtrArrayPtr)
// CHECK: acc.private.recipe @privatization__ZTSPA5_Pi : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s32i> x 5>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
;
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp
index dfb5bbbfda808..6543349f0ae9d 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-CtorDtor.cpp
@@ -14,7 +14,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK: acc.private.recipe @privatization__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -22,17 +22,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -63,16 +63,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUNDS1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -102,11 +102,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -141,16 +141,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][A:B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>> {{.*}}, %[[BOUNDS1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUNDS3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -180,12 +180,12 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -214,11 +214,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -247,7 +247,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUNDS3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -263,7 +263,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -278,7 +278,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -322,7 +322,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUNDS3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -340,7 +340,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -357,7 +357,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -407,7 +407,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK: acc.private.recipe @privatization__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -415,17 +415,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -455,16 +455,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP8CtorDtor : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>> {{.*}}, %[[BOUNDS1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUNDS2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_CtorDtor>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_CtorDtor>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -494,11 +494,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -528,7 +528,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -545,7 +545,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -581,7 +581,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUNDS2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -600,7 +600,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUNDS1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -642,7 +642,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -650,17 +650,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSP8CtorDtor : !cir.ptr<!cir.ptr<!rec_CtorDtor>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_CtorDtor>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!rec_CtorDtor> -> !cir.ptr<!cir.ptr<!rec_CtorDtor>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!rec_CtorDtor>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_CTORDTOR:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_CTORDTOR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_CtorDtor -> !cir.ptr<!rec_CtorDtor>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_CtorDtor>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -691,7 +691,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
@@ -719,7 +719,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp
index 56454e5fb0ce3..4506c957c4422 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-NoOps.cpp
@@ -9,24 +9,24 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK: acc.private.recipe @privatization__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
#pragma acc parallel private(ThreePtr[A])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -56,16 +56,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -96,11 +96,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -133,16 +133,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -173,11 +173,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -207,11 +207,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -241,7 +241,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -257,7 +257,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -272,7 +272,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -322,7 +322,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK: acc.private.recipe @privatization__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -330,17 +330,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -370,16 +370,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -409,11 +409,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -443,7 +443,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -460,7 +460,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
//
// CHECK-NEXT: cir.for : cond {
@@ -500,7 +500,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!rec_NoOps>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -508,17 +508,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSP5NoOps : !cir.ptr<!cir.ptr<!rec_NoOps>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!rec_NoOps>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_NOOPS:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_NOOPS]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -549,7 +549,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i
diff --git a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp
index 4e5265ba38b41..eeb52ded8b4fb 100644
--- a/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/private-clause-pointer-recipes-int.cpp
@@ -7,24 +7,24 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr)
// CHECK: acc.private.recipe @privatization__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
#pragma acc parallel private(ThreePtr[A])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -54,17 +54,17 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -94,10 +94,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -131,16 +131,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(ThreePtr[B][B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt3__ZTSPPPi : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -171,11 +171,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -204,10 +204,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -245,7 +245,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -253,17 +253,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt1__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -294,16 +294,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(TwoPtr[B][B])
// CHECK-NEXT: acc.private.recipe @privatization__Bcnt2__ZTSPPi : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!s32i>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[INT_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -333,11 +333,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -373,7 +373,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel private(OnePtr)
// CHECK-NEXT: acc.private.recipe @privatization__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!s32i>> {{.*}}):
-// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: cir.alloca "openacc.private.init" align(8) : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: acc.yield
// CHECK-NEXT:}
;
@@ -381,17 +381,17 @@ void do_things(unsigned A, unsigned B) {
// CHECK: acc.private.recipe @privatization__Bcnt1__ZTSPi : !cir.ptr<!cir.ptr<!s32i>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!s32i>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}):
// 'init' section:
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.private.init" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
//
// CHECK-NEXT: %[[INT_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !s32i -> !cir.ptr<!s32i>
+// CHECK-NEXT: %[[INT_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!s32i>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
diff --git a/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp b/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp
index 667ec4bc3d00a..1a2e377a997d0 100644
--- a/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/reduction-clause-recipes.cpp
@@ -13,7 +13,7 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel reduction(+:ThreeArr[B][B][B])
// CHECK:acc.reduction.recipe @reduction_add__Bcnt3__ZTSA5_A5_A5_5NoOps : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> reduction_operator <add> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(4) !cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5> -> !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(4) : !cir.ptr<!cir.array<!cir.array<!cir.array<!rec_NoOps x 5> x 5> x 5>>
//
// Init Section:
// CHECK-NEXT: cir.scope {
@@ -21,7 +21,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -36,7 +36,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -51,7 +51,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -96,7 +96,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -113,7 +113,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -130,7 +130,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -180,7 +180,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB3_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -197,7 +197,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB2_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -214,7 +214,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[LAST_SUB_ONE:.*]] = cir.sub %[[UB1_CAST]], %[[ONE]] : !u64i
// CHECK-NEXT: cir.store %[[LAST_SUB_ONE]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -259,16 +259,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel reduction(*:ThreePtr[B][B][A:B])
// CHECK: acc.reduction.recipe @reduction_mul__Bcnt3__ZTSPPP5NoOps : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> reduction_operator <mul> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(8) !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>> -> !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
+// CHECK-NEXT: %[[TOP_LEVEL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(8) : !cir.ptr<!cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>>
//
// CHECK-NEXT: %[[INT_PTR_PTR_PTR_UPPER_BOUND:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UPPER_BOUND_CAST:.*]] = builtin.unrealized_conversion_cast %[[INT_PTR_PTR_PTR_UPPER_BOUND]] : index to !u64i
// CHECK-NEXT: %[[SIZEOF_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[UPPER_BOUND_CAST]], %[[SIZEOF_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!cir.ptr<!rec_NoOps>> -> !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
+// CHECK-NEXT: %[[INT_PTR_PTR_VLA_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!cir.ptr<!rec_NoOps>>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -298,12 +298,12 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS:.*]] = cir.mul %[[UPPER_BOUND_CAST_2]], %[[UPPER_BOUND_CAST]] : !u64i
// CHECK-NEXT: %[[SIZEOF_PTR_PTR:.*]] = cir.const #cir.int<8> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS]], %[[SIZEOF_PTR_PTR]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[CALC_ALLOCA_SIZE]] : !u64i, !cir.ptr<!rec_NoOps> -> !cir.ptr<!cir.ptr<!rec_NoOps>>
+// CHECK-NEXT: %[[INT_PTR_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!cir.ptr<!rec_NoOps>>
//
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -332,11 +332,11 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS_2:.*]] = cir.mul %[[UPPER_BOUND_CAST_3]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[SIZEOF_INT:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[CALC_ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS_2]], %[[SIZEOF_INT]] : !u64i
-// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[CALC_ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[INT_PTR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[CALC_ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// Copy array pointer to the original alloca.
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -365,7 +365,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -381,7 +381,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -396,7 +396,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -442,7 +442,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -460,7 +460,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -477,7 +477,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -527,7 +527,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -545,7 +545,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -562,7 +562,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
@@ -609,16 +609,16 @@ void do_things(unsigned A, unsigned B) {
#pragma acc parallel reduction(||:PtrArrayPtr[B][B][B])
// CHECK-NEXT: acc.reduction.recipe @reduction_lor__Bcnt3__ZTSPA5_P5NoOps : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> reduction_operator <lor> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND2:.*]]: !acc.data_bounds_ty {{.*}}, %[[BOUND3:.*]]: !acc.data_bounds_ty {{.*}}):
-// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(8) !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>> -> !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
+// CHECK-NEXT: %[[TL_ALLOCA:.*]] = cir.alloca "openacc.reduction.init" align(8) : !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>>
//
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
// CHECK-NEXT: %[[ARR_SIZE:.*]] = cir.const #cir.int<40> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[UB3_CAST]], %[[ARR_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) %[[ALLOCA_SIZE]] : !u64i, !cir.array<!cir.ptr<!rec_NoOps> x 5> -> !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
+// CHECK-NEXT: %[[ARR_ALLOCA:.*]] = cir.alloca "openacc.init.bounds" align(8) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!cir.array<!cir.ptr<!rec_NoOps> x 5>>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -654,10 +654,10 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[NUM_ELTS2:.*]] = cir.mul %[[UB1_CAST]], %[[NUM_ELTS]] : !u64i
// CHECK-NEXT: %[[ELT_SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CHECK-NEXT: %[[ALLOCA_SIZE:.*]] = cir.mul %[[NUM_ELTS2]], %[[ELT_SIZE]] : !u64i
-// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) %[[ALLOCA_SIZE]] : !u64i, !rec_NoOps -> !cir.ptr<!rec_NoOps>
+// CHECK-NEXT: %[[ARR_ALLOCA2:.*]] = cir.alloca "openacc.init.bounds" align(4) size(%[[ALLOCA_SIZE]]) : !cir.ptr<!rec_NoOps>
//
// CHECK-NEXT: cir.scope {
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR:.*]] = cir.alloca "itr" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u64i
// CHECK-NEXT: cir.store %[[ZERO]], %[[ITR]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
@@ -684,7 +684,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -699,7 +699,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -714,7 +714,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -759,7 +759,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB3_CAST]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR3_LOAD:.*]] = cir.load %[[ITR3]] : !cir.ptr<!u64i>, !u64i
@@ -776,7 +776,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB2_CAST]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR2_LOAD:.*]] = cir.load %[[ITR2]] : !cir.ptr<!u64i>, !u64i
@@ -793,7 +793,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: cir.store %[[LB1_CAST]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[ITR1_LOAD:.*]] = cir.load %[[ITR1]] : !cir.ptr<!u64i>, !u64i
@@ -851,7 +851,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB3]] : index to !u64i
// CHECK-NEXT: %[[UB3:.*]] = acc.get_upperbound %[[BOUND3]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB3_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB3]] : index to !u64i
-// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR3:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB3:.*]] = cir.sub %[[UB3_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB3]], %[[ITR3]] : !u64i, !cir.ptr<!u64i>
@@ -869,7 +869,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB2]] : index to !u64i
// CHECK-NEXT: %[[UB2:.*]] = acc.get_upperbound %[[BOUND2]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB2_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB2]] : index to !u64i
-// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR2:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB2:.*]] = cir.sub %[[UB2_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB2]], %[[ITR2]] : !u64i, !cir.ptr<!u64i>
@@ -886,7 +886,7 @@ void do_things(unsigned A, unsigned B) {
// CHECK-NEXT: %[[LB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB1]] : index to !u64i
// CHECK-NEXT: %[[UB1:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index
// CHECK-NEXT: %[[UB1_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB1]] : index to !u64i
-// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK-NEXT: %[[ITR1:.*]] = cir.alloca "iter" align(8) : !cir.ptr<!u64i>
// CHECK-NEXT: %[[CONST_ONE:.*]] = cir.const #cir.int<1> : !u64i
// CHECK-NEXT: %[[ONE_BELOW_UB1:.*]] = cir.sub %[[UB1_CAST]], %[[CONST_ONE]] : !u64i
// CHECK-NEXT: cir.store %[[ONE_BELOW_UB1]], %[[ITR1]] : !u64i, !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGenOpenACC/serial.c b/clang/test/CIR/CodeGenOpenACC/serial.c
index 9bb4a84bb47eb..fb55c5a0a3685 100644
--- a/clang/test/CIR/CodeGenOpenACC/serial.c
+++ b/clang/test/CIR/CodeGenOpenACC/serial.c
@@ -2,7 +2,7 @@
void acc_serial(int cond) {
// CHECK: cir.func{{.*}} @acc_serial(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc serial
{}
@@ -269,8 +269,8 @@ void acc_serial(int cond) {
void acc_serial_data_clauses(int *arg1, int *arg2) {
// CHECK: cir.func{{.*}} @acc_serial_data_clauses(%[[ARG1_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}, %[[ARG2_PARAM:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG1:.*]] = cir.alloca "arg1" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[ARG2:.*]] = cir.alloca "arg2" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG1_PARAM]], %[[ARG1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG2_PARAM]], %[[ARG2]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/set.c b/clang/test/CIR/CodeGenOpenACC/set.c
index baf7f268f14a3..2950f142aea1b 100644
--- a/clang/test/CIR/CodeGenOpenACC/set.c
+++ b/clang/test/CIR/CodeGenOpenACC/set.c
@@ -2,7 +2,7 @@
void acc_set(int cond) {
// CHECK: cir.func{{.*}} @acc_set(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc set device_type(*)
diff --git a/clang/test/CIR/CodeGenOpenACC/shutdown.c b/clang/test/CIR/CodeGenOpenACC/shutdown.c
index 22329bfafe6eb..07b8fb8df1043 100644
--- a/clang/test/CIR/CodeGenOpenACC/shutdown.c
+++ b/clang/test/CIR/CodeGenOpenACC/shutdown.c
@@ -2,7 +2,7 @@
void acc_shutdown(int cond) {
// CHECK: cir.func{{.*}} @acc_shutdown(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc shutdown
// CHECK-NEXT: acc.shutdown loc(#{{[a-zA-Z0-9]+}}){{$}}
diff --git a/clang/test/CIR/CodeGenOpenACC/update.c b/clang/test/CIR/CodeGenOpenACC/update.c
index 8d7e1892e4e75..9282bc971af60 100644
--- a/clang/test/CIR/CodeGenOpenACC/update.c
+++ b/clang/test/CIR/CodeGenOpenACC/update.c
@@ -2,8 +2,8 @@
void acc_update(int parmVar, int *ptrParmVar) {
// CHECK: cir.func{{.*}} @acc_update(%[[ARG:.*]]: !s32i{{.*}}, %[[PTRARG:.*]]: !cir.ptr<!s32i>{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %[[PARM:.*]] = cir.alloca "parmVar" {{.*}} init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[PTRPARM:.*]] = cir.alloca "ptrParmVar" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %[[ARG]], %[[PARM]] : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[PTRARG]], %[[PTRPARM]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenACC/wait.c b/clang/test/CIR/CodeGenOpenACC/wait.c
index 435c17899b958..91ed0626d9950 100644
--- a/clang/test/CIR/CodeGenOpenACC/wait.c
+++ b/clang/test/CIR/CodeGenOpenACC/wait.c
@@ -2,7 +2,7 @@
void acc_wait(int cond) {
// CHECK: cir.func{{.*}} @acc_wait(%[[ARG:.*]]: !s32i{{.*}}) {{.*}}{
- // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[COND:.*]] = cir.alloca "cond" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %[[ARG]], %[[COND]] : !s32i, !cir.ptr<!s32i>
#pragma acc wait
diff --git a/clang/test/CIR/CodeGenOpenCL/as_type.cl b/clang/test/CIR/CodeGenOpenCL/as_type.cl
index 7fbda3da9622f..da59e6451c912 100644
--- a/clang/test/CIR/CodeGenOpenCL/as_type.cl
+++ b/clang/test/CIR/CodeGenOpenCL/as_type.cl
@@ -15,8 +15,8 @@ char4 f4(int x) {
}
// CIR: cir.func {{.*}} @f4
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s8i> -> !cir.ptr<!cir.vector<4 x !s8i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s8i>>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[X_V4_I8:.*]] = cir.cast bitcast %[[TMP_X]] : !s32i -> !cir.vector<4 x !s8i>
@@ -33,8 +33,8 @@ int f6(char4 x) {
}
// CIR: cir.func {{.*}} @f6
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !cir.vector<4 x !s8i> -> !cir.ptr<!cir.vector<4 x !s8i>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.vector<4 x !s8i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !cir.vector<4 x !s8i>, !cir.ptr<!cir.vector<4 x !s8i>>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!cir.vector<4 x !s8i>>, !cir.vector<4 x !s8i>
// CIR: %[[X_S32I:.*]] = cir.cast bitcast %[[TMP_X]] : !cir.vector<4 x !s8i> -> !s32i
@@ -51,8 +51,8 @@ int* int_to_ptr(int x) {
}
// CIR: cir.func {{.*}} @int_to_ptr
-// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!s32i>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[X_PTR:.*]] = cir.cast int_to_ptr %[[TMP_X]] : !s32i -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenCL/vector.cl b/clang/test/CIR/CodeGenOpenCL/vector.cl
index 988dd07ee9877..7212ef22c026d 100644
--- a/clang/test/CIR/CodeGenOpenCL/vector.cl
+++ b/clang/test/CIR/CodeGenOpenCL/vector.cl
@@ -14,10 +14,10 @@ int4 vec_ternary(int4 c, int4 a, int4 b) {
return c ? a : c;
}
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
@@ -44,10 +44,10 @@ float4 vec_ternary_f4(int4 c, float4 a, float4 b) {
return c ? a : b;
}
-// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} !cir.vector<4 x !cir.float> -> !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[C_ADDR:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %{{.*}}, %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: cir.store %{{.*}}, %[[A_ADDR]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: cir.store %{{.*}}, %[[B_ADDR]] : !cir.vector<4 x !cir.float>, !cir.ptr<!cir.vector<4 x !cir.float>>
diff --git a/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c b/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c
index 04ccb4396344a..a0343d567f938 100644
--- a/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c
+++ b/clang/test/CIR/CodeGenOpenMP/omp-llvmir.c
@@ -6,11 +6,11 @@
// RUN: FileCheck --input-file=%t.ll %s --check-prefix=OGCG
// CIR-LABEL: cir.func no_inline no_proto dso_local @main() -> !s32i {{.*}}{
-// CIR: [[RETVAL:%.*]] = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
-// CIR: [[J:%.*]] = cir.alloca "j" align(4) !s32i -> !cir.ptr<!s32i>
+// CIR: [[RETVAL:%.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR: [[J:%.*]] = cir.alloca "j" align(4) : !cir.ptr<!s32i>
// CIR: omp.parallel {
// CIR: cir.scope {
-// CIR: [[I:%.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+// CIR: [[I:%.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CIR: [[ZERO1:%.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.store align(4) [[ZERO1]], [[I]] : !s32i, !cir.ptr<!s32i>
// CIR: cir.for : cond {
diff --git a/clang/test/CIR/IR/alloca.cir b/clang/test/CIR/IR/alloca.cir
index effeabb380cca..bad7e074f5aa1 100644
--- a/clang/test/CIR/IR/alloca.cir
+++ b/clang/test/CIR/IR/alloca.cir
@@ -7,12 +7,12 @@
!void = !cir.void
module {
cir.func dso_local @_Z11test_allocam(%arg0: !u64i) -> !cir.ptr<!void> {
- %0 = cir.alloca "n" align(8) init !u64i -> !cir.ptr<!u64i>
- %1 = cir.alloca "__retval" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %0 = cir.alloca "n" align(8) init : !cir.ptr<!u64i>
+ %1 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!void>>
cir.store %arg0, %0 : !u64i, !cir.ptr<!u64i>
%2 = cir.load align(8) %0 : !cir.ptr<!u64i>, !u64i
// Dynamically sized alloca
- %3 = cir.alloca "bi_alloca" align(16) %2 : !u64i, !u8i -> !cir.ptr<!u8i>
+ %3 = cir.alloca "bi_alloca" align(16) size(%2) : !cir.ptr<!u8i>
%4 = cir.cast bitcast %3 : !cir.ptr<!u8i> -> !cir.ptr<!void>
cir.store %4, %1 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
%5 = cir.load %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
@@ -20,11 +20,11 @@ module {
}
// CHECK: cir.func dso_local @_Z11test_allocam(%arg0: !u64i) -> !cir.ptr<!void> {
- // CHECK: %0 = cir.alloca "n" align(8) init !u64i -> !cir.ptr<!u64i>
- // CHECK: %1 = cir.alloca "__retval" align(8) !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ // CHECK: %0 = cir.alloca "n" align(8) init : !cir.ptr<!u64i>
+ // CHECK: %1 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.ptr<!void>>
// CHECK: cir.store %arg0, %0 : !u64i, !cir.ptr<!u64i>
// CHECK: %2 = cir.load align(8) %0 : !cir.ptr<!u64i>, !u64i
- // CHECK: %3 = cir.alloca "bi_alloca" align(16) %2 : !u64i, !u8i -> !cir.ptr<!u8i>
+ // CHECK: %3 = cir.alloca "bi_alloca" align(16) size(%2) : !cir.ptr<!u8i>
// CHECK: %4 = cir.cast bitcast %3 : !cir.ptr<!u8i> -> !cir.ptr<!void>
// CHECK: cir.store %4, %1 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CHECK: %5 = cir.load %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
@@ -33,39 +33,39 @@ module {
// Parse tests for all flag combinations
cir.func dso_local @test_alloca_flags() {
// No flags
- %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) : !cir.ptr<!s32i>
// init only
- %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// const only
- %2 = cir.alloca "c" align(4) const !s32i -> !cir.ptr<!s32i>
+ %2 = cir.alloca "c" align(4) const : !cir.ptr<!s32i>
// init + const
- %3 = cir.alloca "d" align(4) init const !s32i -> !cir.ptr<!s32i>
+ %3 = cir.alloca "d" align(4) init const : !cir.ptr<!s32i>
// cleanup_dest_slot only
- %4 = cir.alloca "e" align(4) cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+ %4 = cir.alloca "e" align(4) cleanup_dest_slot : !cir.ptr<!s32i>
// all flags
- %6 = cir.alloca "f" align(4) init const cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
+ %6 = cir.alloca "f" align(4) init const cleanup_dest_slot : !cir.ptr<!s32i>
// dynamic size, no flags
%sz = cir.const #cir.int<4> : !u64i
- %7 = cir.alloca "h" align(16) %sz : !u64i, !u8i -> !cir.ptr<!u8i>
+ %7 = cir.alloca "h" align(16) size(%sz) : !cir.ptr<!u8i>
// dynamic size + init
- %8 = cir.alloca "i" align(16) init %sz : !u64i, !u8i -> !cir.ptr<!u8i>
+ %8 = cir.alloca "i" align(16) init size(%sz) : !cir.ptr<!u8i>
cir.return
}
// CHECK-LABEL: cir.func dso_local @test_alloca_flags
- // CHECK: cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
- // CHECK: cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
- // CHECK: cir.alloca "c" align(4) const !s32i -> !cir.ptr<!s32i>
- // CHECK: cir.alloca "d" align(4) init const !s32i -> !cir.ptr<!s32i>
- // CHECK: cir.alloca "e" align(4) cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
- // CHECK: cir.alloca "f" align(4) init const cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
- // CHECK: cir.alloca "h" align(16) %{{.*}} : !u64i, !u8i -> !cir.ptr<!u8i>
- // CHECK: cir.alloca "i" align(16) init %{{.*}} : !u64i, !u8i -> !cir.ptr<!u8i>
+ // CHECK: cir.alloca "a" align(4) : !cir.ptr<!s32i>
+ // CHECK: cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+ // CHECK: cir.alloca "c" align(4) const : !cir.ptr<!s32i>
+ // CHECK: cir.alloca "d" align(4) init const : !cir.ptr<!s32i>
+ // CHECK: cir.alloca "e" align(4) cleanup_dest_slot : !cir.ptr<!s32i>
+ // CHECK: cir.alloca "f" align(4) init const cleanup_dest_slot : !cir.ptr<!s32i>
+ // CHECK: cir.alloca "h" align(16) size(%{{.*}}) : !cir.ptr<!u8i>
+ // CHECK: cir.alloca "i" align(16) init size(%{{.*}}) : !cir.ptr<!u8i>
}
diff --git a/clang/test/CIR/IR/array-ctor.cir b/clang/test/CIR/IR/array-ctor.cir
index 9d6573ed9503c..d93111c12cb26 100644
--- a/clang/test/CIR/IR/array-ctor.cir
+++ b/clang/test/CIR/IR/array-ctor.cir
@@ -8,7 +8,7 @@
module {
cir.func private @_ZN1SC1Ev(!cir.ptr<!rec_S>)
cir.func dso_local @_Z3foov() {
- %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+ %0 = cir.alloca "s" align(16) init : !cir.ptr<!cir.array<!rec_S x 42>>
cir.array.ctor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
^bb0(%arg0: !cir.ptr<!rec_S>):
cir.call @_ZN1SC1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
@@ -18,7 +18,7 @@ module {
// CHECK: cir.func private @_ZN1SC1Ev(!cir.ptr<!rec_S>)
// CHECK: cir.func dso_local @_Z3foov() {
- // CHECK: %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+ // CHECK: %0 = cir.alloca "s" align(16) init : !cir.ptr<!cir.array<!rec_S x 42>>
// CHECK: cir.array.ctor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
// CHECK: ^bb0(%arg0: !cir.ptr<!rec_S>):
// CHECK: cir.call @_ZN1SC1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
diff --git a/clang/test/CIR/IR/array-dtor.cir b/clang/test/CIR/IR/array-dtor.cir
index 9a7328ec625a8..f1db38cd85f19 100644
--- a/clang/test/CIR/IR/array-dtor.cir
+++ b/clang/test/CIR/IR/array-dtor.cir
@@ -6,7 +6,7 @@
module {
cir.func private @_ZN1SD1Ev(!cir.ptr<!rec_S>)
cir.func dso_local @_Z3foov() {
- %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+ %0 = cir.alloca "s" align(16) init : !cir.ptr<!cir.array<!rec_S x 42>>
cir.array.dtor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
^bb0(%arg0: !cir.ptr<!rec_S>):
cir.call @_ZN1SD1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
@@ -16,7 +16,7 @@ module {
// CHECK: cir.func private @_ZN1SD1Ev(!cir.ptr<!rec_S>)
// CHECK: cir.func dso_local @_Z3foov() {
- // CHECK: %0 = cir.alloca "s" align(16) init !cir.array<!rec_S x 42> -> !cir.ptr<!cir.array<!rec_S x 42>>
+ // CHECK: %0 = cir.alloca "s" align(16) init : !cir.ptr<!cir.array<!rec_S x 42>>
// CHECK: cir.array.dtor %0 : !cir.ptr<!cir.array<!rec_S x 42>> {
// CHECK: ^bb0(%arg0: !cir.ptr<!rec_S>):
// CHECK: cir.call @_ZN1SD1Ev(%arg0) : (!cir.ptr<!rec_S>) -> ()
diff --git a/clang/test/CIR/IR/array.cir b/clang/test/CIR/IR/array.cir
index ca962b21ffe5d..70c38d09cd8df 100644
--- a/clang/test/CIR/IR/array.cir
+++ b/clang/test/CIR/IR/array.cir
@@ -29,35 +29,35 @@ cir.global external @e = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s
// CHECK: cir.global external @e = #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i], trailing_zeros> : !cir.array<!s32i x 10>
cir.func @func() {
- %0 = cir.alloca "l" align(4) !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
+ %0 = cir.alloca "l" align(4) : !cir.ptr<!cir.array<!s32i x 10>>
cir.return
}
// CHECK: cir.func{{.*}} @func() {
-// CHECK: %0 = cir.alloca "l" align(4) !cir.array<!s32i x 10> -> !cir.ptr<!cir.array<!s32i x 10>>
+// CHECK: %0 = cir.alloca "l" align(4) : !cir.ptr<!cir.array<!s32i x 10>>
// CHECK: cir.return
// CHECK: }
cir.func @func2(%arg0: !cir.ptr<!s32i>) {
- %0 = cir.alloca "p" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ %0 = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
cir.return
}
// CHECK: cir.func{{.*}} @func2(%arg0: !cir.ptr<!s32i>) {
-// CHECK: %0 = cir.alloca "p" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+// CHECK: %0 = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
// CHECK: cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK: cir.return
// CHECK: }
cir.func @func3(%arg0: !cir.ptr<!cir.array<!s32i x 10>>) {
- %0 = cir.alloca "pp" align(8) init !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
+ %0 = cir.alloca "pp" align(8) init : !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
cir.store %arg0, %0 : !cir.ptr<!cir.array<!s32i x 10>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
cir.return
}
// CHECK: cir.func{{.*}} @func3(%arg0: !cir.ptr<!cir.array<!s32i x 10>>) {
-// CHECK: %0 = cir.alloca "pp" align(8) init !cir.ptr<!cir.array<!s32i x 10>> -> !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
+// CHECK: %0 = cir.alloca "pp" align(8) init : !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
// CHECK: cir.store %arg0, %0 : !cir.ptr<!cir.array<!s32i x 10>>, !cir.ptr<!cir.ptr<!cir.array<!s32i x 10>>>
// CHECK: cir.return
// CHECK: }
diff --git a/clang/test/CIR/IR/binassign.cir b/clang/test/CIR/IR/binassign.cir
index e00f42c6e0d3f..902234885bc48 100644
--- a/clang/test/CIR/IR/binassign.cir
+++ b/clang/test/CIR/IR/binassign.cir
@@ -5,10 +5,10 @@
#true = #cir.bool<true> : !cir.bool
module {
cir.func @binary_assign() {
- %0 = cir.alloca "b" align(1) !cir.bool -> !cir.ptr<!cir.bool>
- %1 = cir.alloca "c" align(1) !s8i -> !cir.ptr<!s8i>
- %2 = cir.alloca "f" align(4) !cir.float -> !cir.ptr<!cir.float>
- %3 = cir.alloca "i" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "b" align(1) : !cir.ptr<!cir.bool>
+ %1 = cir.alloca "c" align(1) : !cir.ptr<!s8i>
+ %2 = cir.alloca "f" align(4) : !cir.ptr<!cir.float>
+ %3 = cir.alloca "i" align(4) : !cir.ptr<!s32i>
%4 = cir.const #true
cir.store %4, %0 : !cir.bool, !cir.ptr<!cir.bool>
%5 = cir.const #cir.int<65> : !s32i
@@ -27,10 +27,10 @@ module {
// CHECK: #true = #cir.bool<true> : !cir.bool
// CHECK: module {
// CHECK: cir.func{{.*}} @binary_assign() {
-// CHECK: %0 = cir.alloca "b" align(1) !cir.bool -> !cir.ptr<!cir.bool>
-// CHECK: %1 = cir.alloca "c" align(1) !s8i -> !cir.ptr<!s8i>
-// CHECK: %2 = cir.alloca "f" align(4) !cir.float -> !cir.ptr<!cir.float>
-// CHECK: %3 = cir.alloca "i" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "b" align(1) : !cir.ptr<!cir.bool>
+// CHECK: %1 = cir.alloca "c" align(1) : !cir.ptr<!s8i>
+// CHECK: %2 = cir.alloca "f" align(4) : !cir.ptr<!cir.float>
+// CHECK: %3 = cir.alloca "i" align(4) : !cir.ptr<!s32i>
// CHECK: %4 = cir.const #true
// CHECK: cir.store %4, %0 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK: %5 = cir.const #cir.int<65> : !s32i
diff --git a/clang/test/CIR/IR/bitfield_info.cir b/clang/test/CIR/IR/bitfield_info.cir
index 1e122d2cf909a..cc993cd499ff9 100644
--- a/clang/test/CIR/IR/bitfield_info.cir
+++ b/clang/test/CIR/IR/bitfield_info.cir
@@ -11,7 +11,7 @@
// Use bitfield to enforce printing the attribute
cir.func dso_local @init(%arg0: !cir.ptr<!rec_S> ){
- %0 = cir.alloca "s" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+ %0 = cir.alloca "s" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
cir.store %arg0, %0 : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
%1 = cir.load align(8) %0 : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
%2 = cir.get_member %1[0] {name = "c"} : !cir.ptr<!rec_S> -> !cir.ptr<!u32i>
diff --git a/clang/test/CIR/IR/cmp.cir b/clang/test/CIR/IR/cmp.cir
index 476b4647c19f1..3f8d189ff1e68 100644
--- a/clang/test/CIR/IR/cmp.cir
+++ b/clang/test/CIR/IR/cmp.cir
@@ -4,9 +4,9 @@
module {
cir.func @c0(%arg0: !s32i, %arg1: !s32i) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
- %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+ %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
%3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -37,9 +37,9 @@ module {
}
// CHECK: cir.func{{.*}} @c0(%arg0: !s32i, %arg1: !s32i) {
- // CHECK-NEXT: %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
- // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -70,9 +70,9 @@ module {
// CHECK-NEXT: }
cir.func @c0_unsigned(%arg0: !u32i, %arg1: !u32i) {
- %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
- %1 = cir.alloca "b" align(4) init !u32i -> !cir.ptr<!u32i>
- %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!u32i>
+ %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
cir.store %arg1, %1 : !u32i, !cir.ptr<!u32i>
%3 = cir.load %0 : !cir.ptr<!u32i>, !u32i
@@ -103,9 +103,9 @@ module {
}
// CHECK: cir.func{{.*}} @c0_unsigned(%arg0: !u32i, %arg1: !u32i) {
- // CHECK-NEXT: %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
- // CHECK-NEXT: %1 = cir.alloca "b" align(4) init !u32i -> !cir.ptr<!u32i>
- // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %0 = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(4) init : !cir.ptr<!u32i>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.store %arg1, %1 : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!u32i>, !u32i
@@ -136,9 +136,9 @@ module {
// CHECK-NEXT: }
cir.func @c0_float(%arg0: !cir.float, %arg1: !cir.float) {
- %0 = cir.alloca "a" align(4) init !cir.float -> !cir.ptr<!cir.float>
- %1 = cir.alloca "b" align(4) init !cir.float -> !cir.ptr<!cir.float>
- %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!cir.float>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!cir.float>
+ %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !cir.float, !cir.ptr<!cir.float>
cir.store %arg1, %1 : !cir.float, !cir.ptr<!cir.float>
%3 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
@@ -169,9 +169,9 @@ module {
}
// CHECK: cir.func{{.*}} @c0_float(%arg0: !cir.float, %arg1: !cir.float) {
- // CHECK-NEXT: %0 = cir.alloca "a" align(4) init !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %1 = cir.alloca "b" align(4) init !cir.float -> !cir.ptr<!cir.float>
- // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %0 = cir.alloca "a" align(4) init : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(4) init : !cir.ptr<!cir.float>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: cir.store %arg1, %1 : !cir.float, !cir.ptr<!cir.float>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
@@ -202,9 +202,9 @@ module {
// CHECK-NEXT: }
cir.func @pointer_cmp(%arg0: !cir.ptr<!s32i>, %arg1: !cir.ptr<!s32i>) {
- %0 = cir.alloca "a" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- %1 = cir.alloca "b" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "a" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
+ %1 = cir.alloca "b" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
+ %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
cir.store %arg1, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
%3 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -235,9 +235,9 @@ module {
}
// CHECK: cir.func{{.*}} @pointer_cmp(%arg0: !cir.ptr<!s32i>, %arg1: !cir.ptr<!s32i>) {
- // CHECK-NEXT: %0 = cir.alloca "a" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %1 = cir.alloca "b" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
- // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %0 = cir.alloca "a" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: cir.store %arg1, %1 : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -268,9 +268,9 @@ module {
// CHECK-NEXT: }
cir.func @bool_cmp(%arg0: !cir.bool, %arg1: !cir.bool) {
- %0 = cir.alloca "a" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
- %1 = cir.alloca "b" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
- %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "a" align(1) init : !cir.ptr<!cir.bool>
+ %1 = cir.alloca "b" align(1) init : !cir.ptr<!cir.bool>
+ %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
cir.store %arg1, %1 : !cir.bool, !cir.ptr<!cir.bool>
%3 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
@@ -313,9 +313,9 @@ module {
}
// CHECK: cir.func{{.*}} @bool_cmp(%arg0: !cir.bool, %arg1: !cir.bool) {
- // CHECK-NEXT: %0 = cir.alloca "a" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
- // CHECK-NEXT: %1 = cir.alloca "b" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
- // CHECK-NEXT: %2 = cir.alloca "x" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %0 = cir.alloca "a" align(1) init : !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %1 = cir.alloca "b" align(1) init : !cir.ptr<!cir.bool>
+ // CHECK-NEXT: %2 = cir.alloca "x" align(1) init : !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: cir.store %arg1, %1 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: %3 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
diff --git a/clang/test/CIR/IR/construct-catch-param.cir b/clang/test/CIR/IR/construct-catch-param.cir
index 464411831fd8a..11c8af5e1b1c1 100644
--- a/clang/test/CIR/IR/construct-catch-param.cir
+++ b/clang/test/CIR/IR/construct-catch-param.cir
@@ -29,7 +29,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E(
// enclosing scope) followed by `cir.begin_catch`.
cir.func @construct_catch_param_basic() {
cir.scope {
- %param = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %param = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -51,7 +51,7 @@ cir.func @construct_catch_param_basic() {
}
// CHECK-LABEL: cir.func @construct_catch_param_basic()
-// CHECK: %[[E:.*]] = cir.alloca "e" {{.*}} !rec_E -> !cir.ptr<!rec_E>
+// CHECK: %[[E:.*]] = cir.alloca "e" {{.*}} : !cir.ptr<!rec_E>
// CHECK: cir.try {
// CHECK: cir.yield
// CHECK: } catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
diff --git a/clang/test/CIR/IR/func-attrs.cir b/clang/test/CIR/IR/func-attrs.cir
index 8139562a520f6..351e731231751 100644
--- a/clang/test/CIR/IR/func-attrs.cir
+++ b/clang/test/CIR/IR/func-attrs.cir
@@ -10,42 +10,42 @@
cir.func no_inline dso_local @Func1(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline dso_local @Func1(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
+ %ret = cir.alloca "ret" align(8) : !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func2(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline dso_local @Func2(%arg0: !s32i {llvm.noundef}, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
+ %ret = cir.alloca "ret" align(8) : !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func3(%arg0: !s32i, %arg1: !cir.float {llvm.noundef}) -> !cir.float {
// CHECK: cir.func no_inline dso_local @Func3(%arg0: !s32i, %arg1: !cir.float {llvm.noundef}) -> !cir.float {
- %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
+ %ret = cir.alloca "ret" align(8) : !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func4(%arg0: !s32i, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline dso_local @Func4(%arg0: !s32i, %arg1: !cir.float) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
+ %ret = cir.alloca "ret" align(8) : !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline dso_local @Func5(%arg0: !s32i, %arg1: !cir.float) -> !cir.float {
// CHECK: cir.func no_inline dso_local @Func5(%arg0: !s32i, %arg1: !cir.float) -> !cir.float {
- %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
+ %ret = cir.alloca "ret" align(8) : !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
cir.func no_inline comdat linkonce_odr @MemFunc(%arg0: !cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, %arg1: !s32i {llvm.noundef}, %arg2: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
// CHECK: cir.func no_inline comdat linkonce_odr @MemFunc(%arg0: !cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, %arg1: !s32i {llvm.noundef}, %arg2: !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef}) {
- %ret = cir.alloca "ret" align(8) !cir.float -> !cir.ptr<!cir.float>
+ %ret = cir.alloca "ret" align(8) : !cir.ptr<!cir.float>
%ret_load = cir.load %ret : !cir.ptr<!cir.float>, !cir.float
cir.return %ret_load : !cir.float
}
@@ -64,11 +64,11 @@ cir.func @make_calls() {
cir.call @Func5(%int, %float) : (!s32i, !cir.float) -> (!cir.float)
// CHECK: cir.call @Func5(%{{.*}}, %{{.*}}) : (!s32i, !cir.float) -> !cir.float
- %struct = cir.alloca "s" align(1) !rec_Struct -> !cir.ptr<!rec_Struct>
+ %struct = cir.alloca "s" align(1) : !cir.ptr<!rec_Struct>
cir.call @MemFunc(%struct, %int, %float) : (!cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, !s32i {llvm.noundef, llvm.hot}, !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef})
// CHECK: cir.call @MemFunc(%{{.*}}, %{{.*}}, %{{.*}}) : (!cir.ptr<!rec_Struct> {llvm.align = 1 : i64, llvm.dereferenceable = 1 : i64, llvm.nonnull, llvm.noundef}, !s32i {llvm.hot, llvm.noundef}, !cir.float {llvm.noundef}) -> (!cir.float {llvm.noundef})
- %fptr = cir.alloca "fp" align(8) !cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>> -> !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>>
+ %fptr = cir.alloca "fp" align(8) : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>>
%fptr_load = cir.load align(8) %fptr : !cir.ptr<!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>>, !cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>
cir.call %fptr_load(%int, %float) : (!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>, !s32i {llvm.noundef, llvm.hot}, !cir.float {llvm.noundef}) -> (!s32i {llvm.noundef})
// CHECK: cir.call %{{.*}}(%{{.*}}, %{{.*}}) : (!cir.ptr<!cir.func<(!s32i, !cir.float) -> !s32i>>, !s32i {llvm.hot, llvm.noundef}, !cir.float {llvm.noundef}) -> (!s32i {llvm.noundef})
diff --git a/clang/test/CIR/IR/func.cir b/clang/test/CIR/IR/func.cir
index 5708726c71b30..6d327d60b3266 100644
--- a/clang/test/CIR/IR/func.cir
+++ b/clang/test/CIR/IR/func.cir
@@ -111,7 +111,7 @@ cir.func @ullfunc() -> !u64i {
cir.func coroutine @coro() {
cir.coro.body {
cir.await(init, ready : {
- %0 = cir.alloca "" align(1) !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "" align(1) : !cir.ptr<!cir.bool>
%1 = cir.load align(1) %0 : !cir.ptr<!cir.bool>, !cir.bool
cir.condition(%1)
}, suspend : {
diff --git a/clang/test/CIR/IR/indirect-br.cir b/clang/test/CIR/IR/indirect-br.cir
index 833ac370489bb..9e6566b6fb034 100644
--- a/clang/test/CIR/IR/indirect-br.cir
+++ b/clang/test/CIR/IR/indirect-br.cir
@@ -3,10 +3,10 @@
!void = !cir.void
cir.func @E() {
- %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- %1 = cir.alloca "ptr2" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- %2 = cir.alloca "ptr3" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- %3 = cir.alloca "ptr4" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %0 = cir.alloca "ptr" align(8) init : !cir.ptr<!cir.ptr<!void>>
+ %1 = cir.alloca "ptr2" align(8) init : !cir.ptr<!cir.ptr<!void>>
+ %2 = cir.alloca "ptr3" align(8) init : !cir.ptr<!cir.ptr<!void>>
+ %3 = cir.alloca "ptr4" align(8) init : !cir.ptr<!cir.ptr<!void>>
%4 = cir.block_address <@E, "D"> : !cir.ptr<!void>
cir.store align(8) %4, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
%5 = cir.block_address <@E, "C"> : !cir.ptr<!void>
diff --git a/clang/test/CIR/IR/inline-asm.cir b/clang/test/CIR/IR/inline-asm.cir
index bf91d2c8ea5d8..5134df5f4b5eb 100644
--- a/clang/test/CIR/IR/inline-asm.cir
+++ b/clang/test/CIR/IR/inline-asm.cir
@@ -47,7 +47,7 @@ cir.func @f3() {
}
cir.func @f4(%arg0: !s32i) {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: cir.asm(x86_att,
// CHECK: out = [],
@@ -76,7 +76,7 @@ cir.func @f5() {
cir.return
}
cir.func @f6() -> !s32i {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CHECK: %1 = cir.asm(x86_att,
// CHECK: out = [],
// CHECK: in = [],
@@ -92,7 +92,7 @@ cir.func @f6() -> !s32i {
cir.return %3 : !s32i
}
cir.func @f7(%arg0: !u32i) -> !u32i {
- %0 = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!u32i>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
%1 = cir.load align(4) %0 : !cir.ptr<!u32i>, !u32i
// CHECK: %2 = cir.asm(x86_att,
diff --git a/clang/test/CIR/IR/invalid-complex.cir b/clang/test/CIR/IR/invalid-complex.cir
index b45f4fd0908aa..ad9367e897a98 100644
--- a/clang/test/CIR/IR/invalid-complex.cir
+++ b/clang/test/CIR/IR/invalid-complex.cir
@@ -26,7 +26,7 @@ cir.global external @ci2 = #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> :
module {
cir.func @complex_real_invalid_result_type() -> !cir.double {
- %0 = cir.alloca "c" align(8) !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+ %0 = cir.alloca "c" align(8) : !cir.ptr<!cir.complex<!cir.double>>
%2 = cir.load align(8) %0 : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// expected-error @below {{result type does not match operand type}}
%3 = cir.complex.real %2 : !cir.complex<!cir.double> -> !cir.float
@@ -38,7 +38,7 @@ module {
module {
cir.func @complex_imag_invalid_result_type() -> !cir.double {
- %0 = cir.alloca "c" align(8) !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+ %0 = cir.alloca "c" align(8) : !cir.ptr<!cir.complex<!cir.double>>
%2 = cir.load align(8) %0 : !cir.ptr<!cir.complex<!cir.double>>, !cir.complex<!cir.double>
// expected-error @below {{result type does not match operand type}}
%3 = cir.complex.imag %2 : !cir.complex<!cir.double> -> !cir.float
@@ -51,7 +51,7 @@ module {
module {
cir.func @complex_real_ptr_invalid_result_type() -> !cir.double {
- %0 = cir.alloca "c" align(8) !cir.complex<!cir.double> -> !cir.ptr<!cir.complex<!cir.double>>
+ %0 = cir.alloca "c" align(8) : !cir.ptr<!cir.complex<!cir.double>>
// expected-error @below {{result type does not match operand type}}
%1 = cir.complex.real_ptr %0 : !cir.ptr<!cir.complex<!cir.double>> -> !cir.ptr<!cir.float>
cir.return
diff --git a/clang/test/CIR/IR/invalid-construct-catch-param.cir b/clang/test/CIR/IR/invalid-construct-catch-param.cir
index 09913f9dbc356..7a750c222df1c 100644
--- a/clang/test/CIR/IR/invalid-construct-catch-param.cir
+++ b/clang/test/CIR/IR/invalid-construct-catch-param.cir
@@ -11,7 +11,7 @@ cir.global "private" constant external @_ZTI1E : !cir.ptr<!u8i>
cir.func @copy_fn_missing() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -45,7 +45,7 @@ cir.func private @plain_copy_fn(!cir.ptr<!rec_E>, !cir.ptr<!rec_E>)
cir.func @copy_fn_missing_thunk_attr() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -80,7 +80,7 @@ cir.func private @bad_copy_fn_arity(!cir.ptr<!rec_E>)
cir.func @copy_fn_wrong_arity() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -117,7 +117,7 @@ cir.func private @bad_copy_fn_ret(
cir.func @copy_fn_non_void_return() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -155,7 +155,7 @@ cir.func private @bad_copy_fn_first_arg(
cir.func @copy_fn_first_arg_mismatch() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -193,7 +193,7 @@ cir.func private @bad_copy_fn_second_arg(
cir.func @copy_fn_second_arg_mismatch() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try {
cir.yield
} catch [type #cir.global_view<@_ZTI1E> : !cir.ptr<!u8i>]
@@ -233,7 +233,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E(
// `cir.begin_catch`.
cir.func @construct_not_followed_by_begin_catch() {
cir.scope {
- %p = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %p = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
// expected-error @below {{catch handler region must start with 'cir.begin_catch'}}
cir.try {
cir.yield
diff --git a/clang/test/CIR/IR/invalid-data-member.cir b/clang/test/CIR/IR/invalid-data-member.cir
index 83ef0c996918c..97bde1bc42288 100644
--- a/clang/test/CIR/IR/invalid-data-member.cir
+++ b/clang/test/CIR/IR/invalid-data-member.cir
@@ -35,7 +35,7 @@
module {
cir.func @invalid_base_type(%arg0 : !cir.data_member<!u32i in !struct1>) {
- %0 = cir.alloca "tmp" align(4) !struct2 -> !cir.ptr<!struct2>
+ %0 = cir.alloca "tmp" align(4) : !cir.ptr<!struct2>
// expected-error at +1 {{record type does not match the member pointer type}}
%1 = cir.get_runtime_member %0[%arg0 : !cir.data_member<!u32i in !struct1>] : !cir.ptr<!struct2> -> !cir.ptr<!u32i>
cir.return
@@ -50,7 +50,7 @@ module {
module {
cir.func @invalid_base_type(%arg0 : !cir.data_member<!u32i in !struct1>) {
- %0 = cir.alloca "tmp" align(4) !struct1 -> !cir.ptr<!struct1>
+ %0 = cir.alloca "tmp" align(4) : !cir.ptr<!struct1>
// expected-error at +1 {{result type does not match the member pointer type}}
%1 = cir.get_runtime_member %0[%arg0 : !cir.data_member<!u32i in !struct1>] : !cir.ptr<!struct1> -> !cir.ptr<!u16i>
cir.return
diff --git a/clang/test/CIR/IR/invalid-throw.cir b/clang/test/CIR/IR/invalid-throw.cir
index b038c2696d855..114767a9ad715 100644
--- a/clang/test/CIR/IR/invalid-throw.cir
+++ b/clang/test/CIR/IR/invalid-throw.cir
@@ -5,7 +5,7 @@
module {
cir.func dso_local @throw_without_type_info() {
- %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) : !cir.ptr<!s32i>
// expected-error @below {{'cir.throw' op 'type_info' symbol attribute missing}}
cir.throw %0 : !cir.ptr<!s32i>
cir.unreachable
diff --git a/clang/test/CIR/IR/invalid-try-catch.cir b/clang/test/CIR/IR/invalid-try-catch.cir
index b57b318710547..a40c8efc9acc5 100644
--- a/clang/test/CIR/IR/invalid-try-catch.cir
+++ b/clang/test/CIR/IR/invalid-try-catch.cir
@@ -59,7 +59,7 @@ cir.func dso_local @invalid_catch_empty_block() {
module {
cir.func dso_local @invalid_catch_not_terminated() {
- %a = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %a = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.scope {
cir.try {
cir.yield
diff --git a/clang/test/CIR/IR/method-attr.cir b/clang/test/CIR/IR/method-attr.cir
index dbfe867354e32..732152d6c5713 100644
--- a/clang/test/CIR/IR/method-attr.cir
+++ b/clang/test/CIR/IR/method-attr.cir
@@ -7,7 +7,7 @@
module {
cir.func private @_ZN3Foo2m1Ei(!s32i)
cir.func no_inline dso_local @_Z16make_non_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
- %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
+ %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%1 = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -15,7 +15,7 @@ module {
}
// CHECK: cir.func no_inline dso_local @_Z16make_non_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
-// CHECK: %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
+// CHECK: %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %1 = cir.const #cir.method<@_ZN3Foo2m1Ei> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
// CHECK: cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -23,7 +23,7 @@ module {
// CHECK: }
cir.func no_inline dso_local @_Z12make_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
- %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
+ %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%1 = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -31,7 +31,7 @@ module {
}
// CHECK: cir.func no_inline dso_local @_Z12make_virtualv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
-// CHECK: %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
+// CHECK: %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %1 = cir.const #cir.method<vtable_offset = 8> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
// CHECK: cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -39,7 +39,7 @@ module {
// CHECK: }
cir.func no_inline dso_local @_Z9make_nullv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
- %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
+ %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%1 = cir.const #cir.method<null> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
%2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
@@ -47,7 +47,7 @@ module {
}
// CHECK: cir.func no_inline dso_local @_Z9make_nullv() -> !cir.method<!cir.func<(!s32i)> in !rec_Foo> {
-// CHECK: %0 = cir.alloca "__retval" align(8) !cir.method<!cir.func<(!s32i)> in !rec_Foo> -> !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
+// CHECK: %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %1 = cir.const #cir.method<null> : !cir.method<!cir.func<(!s32i)> in !rec_Foo>
// CHECK: cir.store %1, %0 : !cir.method<!cir.func<(!s32i)> in !rec_Foo>, !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.method<!cir.func<(!s32i)> in !rec_Foo>>, !cir.method<!cir.func<(!s32i)> in !rec_Foo>
diff --git a/clang/test/CIR/IR/resume-flat.cir b/clang/test/CIR/IR/resume-flat.cir
index bb299d6cbbade..243935c3b057e 100644
--- a/clang/test/CIR/IR/resume-flat.cir
+++ b/clang/test/CIR/IR/resume-flat.cir
@@ -6,16 +6,16 @@
module {
cir.func private @flattened_resume() {
- %exception_addr = cir.alloca "exception" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- %type_id_addr = cir.alloca "type_id" align(4) init !u32i -> !cir.ptr<!u32i>
+ %exception_addr = cir.alloca "exception" align(8) init : !cir.ptr<!cir.ptr<!void>>
+ %type_id_addr = cir.alloca "type_id" align(4) init : !cir.ptr<!u32i>
%exception = cir.load %exception_addr : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
%type_id = cir.load %type_id_addr : !cir.ptr<!u32i>, !u32i
cir.resume.flat %exception, %type_id
}
// CHECK: cir.func private @flattened_resume() {
-// CHECK: %[[EXCEPTION_ADDR:.*]] = cir.alloca "exception" {{.*}} init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
-// CHECK: %[[TYPE_ID_ADDR:.*]] = cir.alloca "type_id" {{.*}} init !u32i -> !cir.ptr<!u32i>
+// CHECK: %[[EXCEPTION_ADDR:.*]] = cir.alloca "exception" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
+// CHECK: %[[TYPE_ID_ADDR:.*]] = cir.alloca "type_id" {{.*}} init : !cir.ptr<!u32i>
// CHECK: %[[EXCEPTION:.*]] = cir.load %[[EXCEPTION_ADDR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CHECK: %[[TYPE_ID:.*]] = cir.load %[[TYPE_ID_ADDR]] : !cir.ptr<!u32i>, !u32i
// CHECK: cir.resume.flat %[[EXCEPTION]], %[[TYPE_ID]]
diff --git a/clang/test/CIR/IR/struct.cir b/clang/test/CIR/IR/struct.cir
index 5055896fc9b52..783a56e55ed43 100644
--- a/clang/test/CIR/IR/struct.cir
+++ b/clang/test/CIR/IR/struct.cir
@@ -76,14 +76,14 @@ module {
}
cir.func @structs() {
- %0 = cir.alloca "sc" align(8) init cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>> -> !cir.ptr<!cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>>>
- %1 = cir.alloca "u" align(8) init !cir.ptr<!cir.union<"U" incomplete>> -> !cir.ptr<!cir.ptr<!cir.union<"U" incomplete>>>
+ %0 = cir.alloca "sc" align(8) init : !cir.ptr<!cir.ptr<!cir.struct<"Sc" {!u8i, !u16i, !u32i}>>>
+ %1 = cir.alloca "u" align(8) init : !cir.ptr<!cir.ptr<!cir.union<"U" incomplete>>>
cir.return
}
// CHECK: cir.func @structs() {
-// CHECK: %0 = cir.alloca "sc" {{.*}} init !cir.ptr<!rec_Sc> -> !cir.ptr<!cir.ptr<!rec_Sc>>
-// CHECK: %1 = cir.alloca "u" {{.*}} init !cir.ptr<!rec_U> -> !cir.ptr<!cir.ptr<!rec_U>>
+// CHECK: %0 = cir.alloca "sc" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Sc>>
+// CHECK: %1 = cir.alloca "u" {{.*}} init : !cir.ptr<!cir.ptr<!rec_U>>
cir.func @struct_extract_member_test() {
%0 = cir.const #cir.const_record<{#cir.int<1> : !u8i, #cir.int<2> : !u16i, #cir.int<3> : !u32i}> : !rec_Sc
diff --git a/clang/test/CIR/IR/throw.cir b/clang/test/CIR/IR/throw.cir
index 135391d338a50..d47d17efe3383 100644
--- a/clang/test/CIR/IR/throw.cir
+++ b/clang/test/CIR/IR/throw.cir
@@ -15,9 +15,9 @@ cir.func @throw_with_no_return() {
// CHECK: }
cir.func @throw_with_no_return_2(%arg0: !s32i, %arg1: !s32i) -> !s32i {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
- %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+ %2 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
cir.scope {
@@ -38,9 +38,9 @@ cir.func @throw_with_no_return_2(%arg0: !s32i, %arg1: !s32i) -> !s32i {
}
// CHECK: cir.func @throw_with_no_return_2(%[[ARG_0:.*]]: !s32i, %[[ARG_1:.*]]: !s32i) -> !s32i {
-// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
+// CHECK: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!s32i>
+// CHECK: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CHECK: cir.store %[[ARG_0]], %[[A_ADDR]] : !s32i, !cir.ptr<!s32i>
// CHECK: cir.store %[[ARG_1]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CHECK: cir.scope {
diff --git a/clang/test/CIR/IR/unary.cir b/clang/test/CIR/IR/unary.cir
index ee41457bf237d..12864c17a5705 100644
--- a/clang/test/CIR/IR/unary.cir
+++ b/clang/test/CIR/IR/unary.cir
@@ -7,7 +7,7 @@
module {
cir.func @test_unary_unsigned() {
- %0 = cir.alloca "a" align(4) !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "a" align(4) : !cir.ptr<!u32i>
%1 = cir.load %0 : !cir.ptr<!u32i>, !u32i
%2 = cir.minus %1 : !u32i
%3 = cir.not %1 : !u32i
@@ -16,7 +16,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @test_unary_unsigned() {
-// CHECK: %0 = cir.alloca "a" align(4) !u32i -> !cir.ptr<!u32i>
+// CHECK: %0 = cir.alloca "a" align(4) : !cir.ptr<!u32i>
// CHECK: %1 = cir.load %0 : !cir.ptr<!u32i>, !u32i
// CHECK: %2 = cir.minus %1 : !u32i
// CHECK: %3 = cir.not %1 : !u32i
@@ -26,7 +26,7 @@ module {
// CHECK: }
cir.func @test_unary_signed() {
- %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) : !cir.ptr<!s32i>
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
%2 = cir.minus nsw %1 : !s32i
%3 = cir.not %1 : !s32i
@@ -35,7 +35,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @test_unary_signed() {
-// CHECK: %0 = cir.alloca "a" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "a" align(4) : !cir.ptr<!s32i>
// CHECK: %1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
// CHECK: %2 = cir.minus nsw %1 : !s32i
// CHECK: %3 = cir.not %1 : !s32i
diff --git a/clang/test/CIR/IR/vector.cir b/clang/test/CIR/IR/vector.cir
index 0182fdd34fec1..d744d6f076763 100644
--- a/clang/test/CIR/IR/vector.cir
+++ b/clang/test/CIR/IR/vector.cir
@@ -20,33 +20,33 @@ cir.global external @vec_d = #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2>
// CIR-SAME: !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
cir.func @vec_int_test() {
- %0 = cir.alloca "a" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %1 = cir.alloca "b" align(16) !cir.vector<3 x !s32i> -> !cir.ptr<!cir.vector<3 x !s32i>>
- %2 = cir.alloca "c" align(8) !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
- %3 = cir.alloca "d" align(4) !cir.vector<[1] x !s32i> -> !cir.ptr<!cir.vector<[1] x !s32i>>
+ %0 = cir.alloca "a" align(16) : !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "b" align(16) : !cir.ptr<!cir.vector<3 x !s32i>>
+ %2 = cir.alloca "c" align(8) : !cir.ptr<!cir.vector<2 x !s32i>>
+ %3 = cir.alloca "d" align(4) : !cir.ptr<!cir.vector<[1] x !s32i>>
cir.return
}
// CHECK: cir.func{{.*}} @vec_int_test() {
-// CHECK: %0 = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK: %1 = cir.alloca "b" {{.*}} !cir.vector<3 x !s32i> -> !cir.ptr<!cir.vector<3 x !s32i>>
-// CHECK: %2 = cir.alloca "c" {{.*}} !cir.vector<2 x !s32i> -> !cir.ptr<!cir.vector<2 x !s32i>>
-// CHECK: %3 = cir.alloca "d" {{.*}} !cir.vector<[1] x !s32i> -> !cir.ptr<!cir.vector<[1] x !s32i>>
+// CHECK: %0 = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %1 = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<3 x !s32i>>
+// CHECK: %2 = cir.alloca "c" {{.*}} : !cir.ptr<!cir.vector<2 x !s32i>>
+// CHECK: %3 = cir.alloca "d" {{.*}} : !cir.ptr<!cir.vector<[1] x !s32i>>
// CHECK: cir.return
// CHECK: }
cir.func @vec_double_test() {
- %0 = cir.alloca "a" align(16) !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+ %0 = cir.alloca "a" align(16) : !cir.ptr<!cir.vector<2 x !cir.double>>
cir.return
}
// CHECK: cir.func{{.*}} @vec_double_test() {
-// CHECK: %0 = cir.alloca "a" {{.*}} !cir.vector<2 x !cir.double> -> !cir.ptr<!cir.vector<2 x !cir.double>>
+// CHECK: %0 = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
// CHECK: cir.return
// CHECK: }
cir.func @local_vector_create_test() {
- %0 = cir.alloca "a" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %0 = cir.alloca "a" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
%1 = cir.const #cir.int<1> : !s32i
%2 = cir.const #cir.int<2> : !s32i
%3 = cir.const #cir.int<3> : !s32i
@@ -57,7 +57,7 @@ cir.func @local_vector_create_test() {
}
// CHECK: cir.func{{.*}} @local_vector_create_test() {
-// CHECK: %0 = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %0 = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %1 = cir.const #cir.int<1> : !s32i
// CHECK: %2 = cir.const #cir.int<2> : !s32i
// CHECK: %3 = cir.const #cir.int<3> : !s32i
@@ -68,8 +68,8 @@ cir.func @local_vector_create_test() {
// CHECK: }
cir.func @vector_extract_element_test() {
- %0 = cir.alloca "d" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %1 = cir.alloca "e" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "d" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "e" align(4) init : !cir.ptr<!s32i>
%2 = cir.const #cir.int<1> : !s32i
%3 = cir.const #cir.int<2> : !s32i
%4 = cir.const #cir.int<3> : !s32i
@@ -84,8 +84,8 @@ cir.func @vector_extract_element_test() {
}
// CHECK: cir.func{{.*}} @vector_extract_element_test() {
-// CHECK: %0 = cir.alloca "d" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK: %1 = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %1 = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %2 = cir.const #cir.int<1> : !s32i
// CHECK: %3 = cir.const #cir.int<2> : !s32i
// CHECK: %4 = cir.const #cir.int<3> : !s32i
@@ -100,7 +100,7 @@ cir.func @vector_extract_element_test() {
// CHECK: }
cir.func @vector_insert_element_test() {
- %0 = cir.alloca "a" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %0 = cir.alloca "a" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
%1 = cir.const #cir.int<1> : !s32i
%2 = cir.const #cir.int<2> : !s32i
%3 = cir.const #cir.int<3> : !s32i
@@ -119,7 +119,7 @@ cir.func @vector_insert_element_test() {
}
// CHECK: cir.func{{.*}} @vector_insert_element_test() {
-// CHECK: %0 = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %0 = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %1 = cir.const #cir.int<1> : !s32i
// CHECK: %2 = cir.const #cir.int<2> : !s32i
// CHECK: %3 = cir.const #cir.int<3> : !s32i
@@ -138,9 +138,9 @@ cir.func @vector_insert_element_test() {
// CHECK: }
cir.func @vector_compare_test() {
- %0 = cir.alloca "a" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %1 = cir.alloca "b" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %2 = cir.alloca "o" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %0 = cir.alloca "a" align(16) : !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "b" align(16) : !cir.ptr<!cir.vector<4 x !s32i>>
+ %2 = cir.alloca "o" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
%3 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
cir.store %3, %0 : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
%4 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
@@ -153,9 +153,9 @@ cir.func @vector_compare_test() {
}
// CHECK: cir.func{{.*}} @vector_compare_test() {
-// CHECK: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK: %[[INIT:.*]] = cir.alloca "o" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[INIT:.*]] = cir.alloca "o" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %[[VEC_A_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK: cir.store %[[VEC_A_VAL]], %[[VEC_A]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %[[VEC_B_VAL:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
@@ -168,9 +168,9 @@ cir.func @vector_compare_test() {
// CHECK: }
cir.func @vector_shuffle_dynamic_test() {
- %0 = cir.alloca "a" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %1 = cir.alloca "b" align(16) !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %2 = cir.alloca "r" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %0 = cir.alloca "a" align(16) : !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "b" align(16) : !cir.ptr<!cir.vector<4 x !s32i>>
+ %2 = cir.alloca "r" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
%3 = cir.load align(16) %0 : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
%4 = cir.load align(16) %1 : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
%5 = cir.vec.shuffle.dynamic %3 : !cir.vector<4 x !s32i>, %4 : !cir.vector<4 x !s32i>
@@ -179,9 +179,9 @@ cir.func @vector_shuffle_dynamic_test() {
}
// CHECK: cir.func{{.*}} @vector_shuffle_dynamic_test() {
-// CHECK: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK: %[[RES:.*]] = cir.alloca "r" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[VEC_A:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[VEC_B:.*]] = cir.alloca "b" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK: %[[RES:.*]] = cir.alloca "r" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK: %[[TMP_A:.*]] = cir.load{{.*}} %[[VEC_A]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CHECK: %[[TMP_B:.*]] = cir.load{{.*}} %[[VEC_B]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CHECK: %[[VEC_SHUF:.*]] = cir.vec.shuffle.dynamic %[[TMP_A]] : !cir.vector<4 x !s32i>, %[[TMP_B]] : !cir.vector<4 x !s32i>
@@ -190,8 +190,8 @@ cir.func @vector_shuffle_dynamic_test() {
// CHECK: }
cir.func @vector_splat_test() {
- %0 = cir.alloca "a" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
- %1 = cir.alloca "shl" align(16) init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+ %0 = cir.alloca "a" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
+ %1 = cir.alloca "shl" align(16) init : !cir.ptr<!cir.vector<4 x !s32i>>
%2 = cir.const #cir.int<1> : !s32i
%3 = cir.const #cir.int<2> : !s32i
%4 = cir.const #cir.int<3> : !s32i
@@ -207,8 +207,8 @@ cir.func @vector_splat_test() {
}
// CHECK: cir.func{{.*}} @vector_splat_test() {
-// CHECK-NEXT: %[[VEC:.*]] = cir.alloca "a" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
-// CHECK-NEXT: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init !cir.vector<4 x !s32i> -> !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK-NEXT: %[[VEC:.*]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
+// CHECK-NEXT: %[[SHL_RES:.*]] = cir.alloca "shl" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CHECK-NEXT: %[[CONST_1:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CONST_2:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[CONST_3:.*]] = cir.const #cir.int<3> : !s32i
diff --git a/clang/test/CIR/IR/vtable-addrpt.cir b/clang/test/CIR/IR/vtable-addrpt.cir
index a7575e489dbef..d34b95dd030aa 100644
--- a/clang/test/CIR/IR/vtable-addrpt.cir
+++ b/clang/test/CIR/IR/vtable-addrpt.cir
@@ -10,7 +10,7 @@
module {
cir.global "private" external @_ZTV1S : !rec_anon_struct {alignment = 8 : i64}
cir.func @_ZN1SC2Ev(%arg0: !cir.ptr<!rec_S>) {
- %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_S> -> !cir.ptr<!cir.ptr<!rec_S>>
+ %0 = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
cir.store %arg0, %0 : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
%1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
%2 = cir.vtable.address_point(@_ZTV1S, address_point = <index = 0, offset = 2>) : !cir.vptr
diff --git a/clang/test/CIR/IR/vtt-addrpoint.cir b/clang/test/CIR/IR/vtt-addrpoint.cir
index 5fc1b0b5b97a4..5081d3a0d72f9 100644
--- a/clang/test/CIR/IR/vtt-addrpoint.cir
+++ b/clang/test/CIR/IR/vtt-addrpoint.cir
@@ -13,8 +13,8 @@ module {
cir.func private @_ZN1AC2Ev(!cir.ptr<!rec_A>)
cir.func private @_ZN1BC2Ev(!cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!void>>)
cir.func dso_local @_ZN1CC2Ev(%arg0: !cir.ptr<!rec_C>, %arg1: !cir.ptr<!cir.ptr<!void>>) {
- %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
- %1 = cir.alloca "vtt" align(8) init !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
+ %0 = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_C>>
+ %1 = cir.alloca "vtt" align(8) init : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg1, %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
%2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
@@ -35,7 +35,7 @@ module {
cir.global linkonce_odr dso_local @_ZTV1C = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !rec_anon_struct {alignment = 8 : i64}
cir.global linkonce_odr @_ZTT1C = #cir.const_array<[#cir.global_view<@_ZTV1C, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTC1C0_1B, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 2> {alignment = 8 : i64}
cir.func dso_local @_ZN1CC1Ev(%arg0: !cir.ptr<!rec_C>) {
- %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+ %0 = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
%1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
%2 = cir.base_class_addr %1 : !cir.ptr<!rec_C> nonnull [0] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/Lowering/address-space.cir b/clang/test/CIR/Lowering/address-space.cir
index f23c138b277df..35d9b0430d6cc 100644
--- a/clang/test/CIR/Lowering/address-space.cir
+++ b/clang/test/CIR/Lowering/address-space.cir
@@ -25,21 +25,21 @@ module {
// LLVM: define void @foo(ptr %0)
cir.func @foo(%arg0: !cir.ptr<!s32i>) {
// LLVM-NEXT: alloca ptr,
- %0 = cir.alloca "arg" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ %0 = cir.alloca "arg" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
cir.return
}
// LLVM: define void @bar(ptr addrspace(1) %0)
cir.func @bar(%arg0: !cir.ptr<!s32i, target_address_space(1)>) {
// LLVM-NEXT: alloca ptr addrspace(1)
- %0 = cir.alloca "arg" align(8) init !cir.ptr<!s32i, target_address_space(1)> -> !cir.ptr<!cir.ptr<!s32i, target_address_space(1)>>
+ %0 = cir.alloca "arg" align(8) init : !cir.ptr<!cir.ptr<!s32i, target_address_space(1)>>
cir.return
}
// LLVM: define void @baz(ptr %0)
cir.func @baz(%arg0: !cir.ptr<!s32i, target_address_space(0)>) {
// LLVM-NEXT: alloca ptr,
- %0 = cir.alloca "arg" align(8) init !cir.ptr<!s32i, target_address_space(0)> -> !cir.ptr<!cir.ptr<!s32i, target_address_space(0)>>
+ %0 = cir.alloca "arg" align(8) init : !cir.ptr<!cir.ptr<!s32i, target_address_space(0)>>
cir.return
}
}
diff --git a/clang/test/CIR/Lowering/alloca.cir b/clang/test/CIR/Lowering/alloca.cir
index ce10ddcf4edd5..028d9a5223a9a 100644
--- a/clang/test/CIR/Lowering/alloca.cir
+++ b/clang/test/CIR/Lowering/alloca.cir
@@ -7,7 +7,7 @@ module {
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i64) : i64
// CHECK-NEXT: %{{.*}} = llvm.alloca %[[SIZE]] x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr
cir.func @alloca_i32() {
- %0 = cir.alloca "var_name" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "var_name" align(4) : !cir.ptr<!s32i>
cir.return
}
}
diff --git a/clang/test/CIR/Lowering/binop-bool.cir b/clang/test/CIR/Lowering/binop-bool.cir
index 1baa27f395160..f1f0143cf5f8c 100644
--- a/clang/test/CIR/Lowering/binop-bool.cir
+++ b/clang/test/CIR/Lowering/binop-bool.cir
@@ -3,8 +3,8 @@
module {
cir.func @foo() {
- %0 = cir.alloca "a" align(4) init !cir.bool -> !cir.ptr<!cir.bool>
- %1 = cir.alloca "b" align(4) init !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!cir.bool>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!cir.bool>
%2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
%3 = cir.load %1 : !cir.ptr<!cir.bool>, !cir.bool
%4 = cir.or %2, %3 : !cir.bool
diff --git a/clang/test/CIR/Lowering/binop-fp.cir b/clang/test/CIR/Lowering/binop-fp.cir
index bfb621e77de18..8e6f0036cd97a 100644
--- a/clang/test/CIR/Lowering/binop-fp.cir
+++ b/clang/test/CIR/Lowering/binop-fp.cir
@@ -3,12 +3,12 @@
module {
cir.func @foo() {
- %0 = cir.alloca "c" align(4) !cir.float -> !cir.ptr<!cir.float>
- %1 = cir.alloca "d" align(4) !cir.float -> !cir.ptr<!cir.float>
- %2 = cir.alloca "y" align(4) init !cir.float -> !cir.ptr<!cir.float>
- %3 = cir.alloca "e" align(8) !cir.double -> !cir.ptr<!cir.double>
- %4 = cir.alloca "f" align(8) !cir.double -> !cir.ptr<!cir.double>
- %5 = cir.alloca "g" align(8) init !cir.double -> !cir.ptr<!cir.double>
+ %0 = cir.alloca "c" align(4) : !cir.ptr<!cir.float>
+ %1 = cir.alloca "d" align(4) : !cir.ptr<!cir.float>
+ %2 = cir.alloca "y" align(4) init : !cir.ptr<!cir.float>
+ %3 = cir.alloca "e" align(8) : !cir.ptr<!cir.double>
+ %4 = cir.alloca "f" align(8) : !cir.ptr<!cir.double>
+ %5 = cir.alloca "g" align(8) init : !cir.ptr<!cir.double>
%6 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
%7 = cir.load %1 : !cir.ptr<!cir.float>, !cir.float
%8 = cir.mul %6, %7 : !cir.float
diff --git a/clang/test/CIR/Lowering/binop-signed-int.cir b/clang/test/CIR/Lowering/binop-signed-int.cir
index 26867564df06f..b10cfd982f26a 100644
--- a/clang/test/CIR/Lowering/binop-signed-int.cir
+++ b/clang/test/CIR/Lowering/binop-signed-int.cir
@@ -4,9 +4,9 @@
!s32i = !cir.int<s, 32>
module {
cir.func @foo() {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "b" align(4) init !s32i -> !cir.ptr<!s32i>
- %2 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+ %2 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
%3 = cir.const #cir.int<2> : !s32i cir.store %3, %0 : !s32i, !cir.ptr<!s32i>
%4 = cir.const #cir.int<1> : !s32i cir.store %4, %1 : !s32i, !cir.ptr<!s32i>
%5 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Lowering/binop-unsigned-int.cir b/clang/test/CIR/Lowering/binop-unsigned-int.cir
index 8f3f3d0c11281..2dce740467616 100644
--- a/clang/test/CIR/Lowering/binop-unsigned-int.cir
+++ b/clang/test/CIR/Lowering/binop-unsigned-int.cir
@@ -4,9 +4,9 @@
module {
cir.func @foo() {
- %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
- %1 = cir.alloca "b" align(4) init !u32i -> !cir.ptr<!u32i>
- %2 = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
+ %1 = cir.alloca "b" align(4) init : !cir.ptr<!u32i>
+ %2 = cir.alloca "x" align(4) init : !cir.ptr<!u32i>
%3 = cir.const #cir.int<2> : !u32i cir.store %3, %0 : !u32i, !cir.ptr<!u32i>
%4 = cir.const #cir.int<1> : !u32i cir.store %4, %1 : !u32i, !cir.ptr<!u32i>
%5 = cir.load %0 : !cir.ptr<!u32i>, !u32i
diff --git a/clang/test/CIR/Lowering/cast.cir b/clang/test/CIR/Lowering/cast.cir
index 8b7351d7fc076..fec70e4e27122 100644
--- a/clang/test/CIR/Lowering/cast.cir
+++ b/clang/test/CIR/Lowering/cast.cir
@@ -12,15 +12,15 @@
module {
cir.func @cStyleCasts(%arg0: !u32i, %arg1: !s32i, %arg2: !cir.float, %arg3: !cir.double) -> !s32i {
// CHECK: llvm.func @cStyleCasts
- %0 = cir.alloca "x1" align(4) init !u32i -> !cir.ptr<!u32i>
- %1 = cir.alloca "x2" align(4) init !s32i -> !cir.ptr<!s32i>
- %20 = cir.alloca "x4" align(2) init !s16i -> !cir.ptr<!s16i>
- %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
- %3 = cir.alloca "a" align(1) init !s8i -> !cir.ptr<!s8i>
- %4 = cir.alloca "b" align(2) init !s16i -> !cir.ptr<!s16i>
- %5 = cir.alloca "c" align(8) init !s64i -> !cir.ptr<!s64i>
- %6 = cir.alloca "d" align(8) init !s64i -> !cir.ptr<!s64i>
- %8 = cir.alloca "e" align(8) init !cir.ptr<!s32i> -> !cir.ptr<!cir.ptr<!s32i>>
+ %0 = cir.alloca "x1" align(4) init : !cir.ptr<!u32i>
+ %1 = cir.alloca "x2" align(4) init : !cir.ptr<!s32i>
+ %20 = cir.alloca "x4" align(2) init : !cir.ptr<!s16i>
+ %2 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+ %3 = cir.alloca "a" align(1) init : !cir.ptr<!s8i>
+ %4 = cir.alloca "b" align(2) init : !cir.ptr<!s16i>
+ %5 = cir.alloca "c" align(8) init : !cir.ptr<!s64i>
+ %6 = cir.alloca "d" align(8) init : !cir.ptr<!s64i>
+ %8 = cir.alloca "e" align(8) init : !cir.ptr<!cir.ptr<!s32i>>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
@@ -79,8 +79,8 @@ module {
cir.func @testBoolToIntCast(%arg0: !cir.bool) {
// CHECK: llvm.func @testBoolToIntCast
- %0 = cir.alloca "bl" align(1) init !cir.bool -> !cir.ptr<!cir.bool>
- %1 = cir.alloca "y" align(1) init !u8i -> !cir.ptr<!u8i>
+ %0 = cir.alloca "bl" align(1) init : !cir.ptr<!cir.bool>
+ %1 = cir.alloca "y" align(1) init : !cir.ptr<!u8i>
cir.store %arg0, %0 : !cir.bool, !cir.ptr<!cir.bool>
%2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
diff --git a/clang/test/CIR/Lowering/goto.cir b/clang/test/CIR/Lowering/goto.cir
index 86391b5097f15..75722c41b89ed 100644
--- a/clang/test/CIR/Lowering/goto.cir
+++ b/clang/test/CIR/Lowering/goto.cir
@@ -5,8 +5,8 @@
module {
cir.func @gotoFromIf(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%6 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Lowering/inline-asm.cir b/clang/test/CIR/Lowering/inline-asm.cir
index aad33337a81b2..b510f23595ae6 100644
--- a/clang/test/CIR/Lowering/inline-asm.cir
+++ b/clang/test/CIR/Lowering/inline-asm.cir
@@ -35,7 +35,7 @@ cir.func @f3() {
}
cir.func @f4(%arg0: !s32i) {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: call void asm sideeffect "", "*m,~{dirflag},~{fpsr},~{flags}"(ptr elementtype(i32) %2)
cir.asm(x86_att,
@@ -57,7 +57,7 @@ cir.func @f5() {
}
cir.func @f6() -> !s32i {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
// CHECK: %2 = call i32 asm sideeffect "movl $$42, $0", "=r,~{dirflag},~{fpsr},~{flags}"()
%1 = cir.asm(x86_att,
out = [],
@@ -70,7 +70,7 @@ cir.func @f6() -> !s32i {
}
cir.func @f7(%arg0: !u32i) -> !u32i {
- %0 = cir.alloca "x" align(4) init !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!u32i>
cir.store %arg0, %0 : !u32i, !cir.ptr<!u32i>
%1 = cir.load align(4) %0 : !cir.ptr<!u32i>, !u32i
// CHECK: %4 = call i32 asm sideeffect "addl $$42, $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %3)
diff --git a/clang/test/CIR/Lowering/omp-target-map.cir b/clang/test/CIR/Lowering/omp-target-map.cir
index 5bdd8e042fcf5..c26bfedc031ed 100644
--- a/clang/test/CIR/Lowering/omp-target-map.cir
+++ b/clang/test/CIR/Lowering/omp-target-map.cir
@@ -9,7 +9,7 @@
module {
// CHECK-LABEL: llvm.func @target_map_from
cir.func @target_map_from(%arg0 : !s32i) {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: %[[ALLOCA:.*]] = llvm.alloca {{.*}} x i32
diff --git a/clang/test/CIR/Lowering/resume-flat.cir b/clang/test/CIR/Lowering/resume-flat.cir
index d36dda522d1a6..f92310703d8f8 100644
--- a/clang/test/CIR/Lowering/resume-flat.cir
+++ b/clang/test/CIR/Lowering/resume-flat.cir
@@ -6,8 +6,8 @@
module {
cir.func private @flattened_resume() {
- %exception_addr = cir.alloca "exception" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
- %type_id_addr = cir.alloca "type_id" align(4) init !u32i -> !cir.ptr<!u32i>
+ %exception_addr = cir.alloca "exception" align(8) init : !cir.ptr<!cir.ptr<!void>>
+ %type_id_addr = cir.alloca "type_id" align(4) init : !cir.ptr<!u32i>
%exception = cir.load %exception_addr : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
%type_id = cir.load %type_id_addr : !cir.ptr<!u32i>, !u32i
cir.resume.flat %exception, %type_id
diff --git a/clang/test/CIR/Lowering/switch.cir b/clang/test/CIR/Lowering/switch.cir
index 77efee63c5ad6..78431dc9682ad 100644
--- a/clang/test/CIR/Lowering/switch.cir
+++ b/clang/test/CIR/Lowering/switch.cir
@@ -113,7 +113,7 @@ module {
}
cir.func @shouldLowerMultiBlockCase(%arg0: !s32i) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -142,9 +142,9 @@ module {
// CHECK: }
cir.func @shouldLowerNestedBreak(%arg0: !s32i, %arg1: !s32i) -> !s32i {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
- %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
+ %2 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
cir.scope {
diff --git a/clang/test/CIR/Lowering/vtt-addrpoint.cir b/clang/test/CIR/Lowering/vtt-addrpoint.cir
index 7932fb51ad8cf..2a9a79df7881b 100644
--- a/clang/test/CIR/Lowering/vtt-addrpoint.cir
+++ b/clang/test/CIR/Lowering/vtt-addrpoint.cir
@@ -14,8 +14,8 @@ module {
cir.func private @_ZN1AC2Ev(!cir.ptr<!rec_A>)
cir.func private @_ZN1BC2Ev(!cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!void>>)
cir.func dso_local @_ZN1CC2Ev(%arg0: !cir.ptr<!rec_C>, %arg1: !cir.ptr<!cir.ptr<!void>>) {
- %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
- %1 = cir.alloca "vtt" align(8) init !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
+ %0 = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_C>>
+ %1 = cir.alloca "vtt" align(8) init : !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg1, %1 : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!cir.ptr<!cir.ptr<!void>>>
%2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
@@ -38,7 +38,7 @@ module {
cir.global linkonce_odr dso_local @_ZTV1C = #cir.vtable<{#cir.const_array<[#cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>, #cir.ptr<null> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 3>}> : !rec_anon_struct {alignment = 8 : i64}
cir.global linkonce_odr @_ZTT1C = #cir.const_array<[#cir.global_view<@_ZTV1C, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTC1C0_1B, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 2> {alignment = 8 : i64}
cir.func dso_local @_ZN1CC1Ev(%arg0: !cir.ptr<!rec_C>) {
- %0 = cir.alloca "this" align(8) init !cir.ptr<!rec_C> -> !cir.ptr<!cir.ptr<!rec_C>>
+ %0 = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_C>>
cir.store %arg0, %0 : !cir.ptr<!rec_C>, !cir.ptr<!cir.ptr<!rec_C>>
%1 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_C>>, !cir.ptr<!rec_C>
%2 = cir.base_class_addr %1 : !cir.ptr<!rec_C> nonnull [0] -> !cir.ptr<!rec_A>
diff --git a/clang/test/CIR/Transforms/canonicalize.cir b/clang/test/CIR/Transforms/canonicalize.cir
index 35f8e3a64a5d3..c0a7507029253 100644
--- a/clang/test/CIR/Transforms/canonicalize.cir
+++ b/clang/test/CIR/Transforms/canonicalize.cir
@@ -14,7 +14,7 @@ module {
cir.func @redundant_br() {
cir.br ^bb1
^bb1: // pred: ^bb0
- %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
%1 = cir.const #cir.int<4> : !u32i
cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
cir.br ^bb2
@@ -22,7 +22,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @redundant_br() {
- // CHECK-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+ // CHECK-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
// CHECK-NEXT: %[[FOUR:.*]] = cir.const #cir.int<4> : !u32i
// CHECK-NEXT: cir.store %[[FOUR]], %[[A]] : !u32i, !cir.ptr<!u32i>
// CHECK-NEXT: cir.return
diff --git a/clang/test/CIR/Transforms/complex-create-fold.cir b/clang/test/CIR/Transforms/complex-create-fold.cir
index 6b1c47494a5ef..ca5b603f99441 100644
--- a/clang/test/CIR/Transforms/complex-create-fold.cir
+++ b/clang/test/CIR/Transforms/complex-create-fold.cir
@@ -4,8 +4,8 @@
module {
cir.func @fold_complex_create_test() -> !cir.complex<!s32i> {
- %0 = cir.alloca "__retval" align(4) !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
- %1 = cir.alloca "c" align(4) init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+ %0 = cir.alloca "__retval" align(4) : !cir.ptr<!cir.complex<!s32i>>
+ %1 = cir.alloca "c" align(4) init : !cir.ptr<!cir.complex<!s32i>>
%2 = cir.const #cir.int<1> : !s32i
%3 = cir.const #cir.int<2> : !s32i
%4 = cir.complex.create %2, %3 : !s32i -> !cir.complex<!s32i>
@@ -17,8 +17,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_complex_create_test() -> !cir.complex<!s32i> {
-// CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
-// CHECK: %[[INIT:.*]] = cir.alloca "c" {{.*}} init !cir.complex<!s32i> -> !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CHECK: %[[INIT:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[COMPLEX:.*]] = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
// CHECK: cir.store{{.*}} %[[COMPLEX]], %[[INIT]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
// CHECK: %[[TMP:.*]] = cir.load{{.*}} %[[INIT]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
diff --git a/clang/test/CIR/Transforms/complex-imag-fold.cir b/clang/test/CIR/Transforms/complex-imag-fold.cir
index b6cc54e2f5c32..a93e14c6871e6 100644
--- a/clang/test/CIR/Transforms/complex-imag-fold.cir
+++ b/clang/test/CIR/Transforms/complex-imag-fold.cir
@@ -4,7 +4,7 @@
module {
cir.func @fold_complex_imag_test() -> !s32i {
- %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
%2 = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
%4 = cir.complex.imag %2 : !cir.complex<!s32i> -> !s32i
cir.store %4, %0 : !s32i, !cir.ptr<!s32i>
@@ -13,7 +13,7 @@ module {
}
// CHECK: cir.func @fold_complex_imag_test() -> !s32i {
- // CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CHECK: %[[IMAG:.*]] = cir.const #cir.int<2> : !s32i
// CHECK: cir.store %[[IMAG]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[TMP:.]] = cir.load %[[RET]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/complex-real-fold.cir b/clang/test/CIR/Transforms/complex-real-fold.cir
index c95e94968ff67..1b9b932ce9659 100644
--- a/clang/test/CIR/Transforms/complex-real-fold.cir
+++ b/clang/test/CIR/Transforms/complex-real-fold.cir
@@ -4,7 +4,7 @@
module {
cir.func @fold_complex_real_test() -> !s32i {
- %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
%2 = cir.const #cir.const_complex<#cir.int<1> : !s32i, #cir.int<2> : !s32i> : !cir.complex<!s32i>
%4 = cir.complex.real %2 : !cir.complex<!s32i> -> !s32i
cir.store %4, %0 : !s32i, !cir.ptr<!s32i>
@@ -13,7 +13,7 @@ module {
}
// CHECK: cir.func @fold_complex_real_test() -> !s32i {
- // CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} !s32i -> !cir.ptr<!s32i>
+ // CHECK: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
// CHECK: %[[REAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK: cir.store %[[REAL]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// CHECK: %[[TMP:.]] = cir.load %[[RET]] : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir
index 9ba79ce825c6d..d2e1bbfc7077b 100644
--- a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir
+++ b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch-invalid.cir
@@ -32,7 +32,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E_ok(
// Only non_trivial_copy is currently supported on Itanium.
cir.func @bad_kind() {
- %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %0 = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb6
@@ -85,7 +85,7 @@ cir.func private @__clang_cir_catch_copy__ZTS1E_decl(
attributes {cir.eh.catch_copy_thunk}
cir.func @copy_fn_no_body() {
- %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %0 = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb6
@@ -146,7 +146,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E_multi(
}
cir.func @multi_block_thunk() {
- %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %0 = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb6
diff --git a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir
index 5388953701515..cffd1892845f8 100644
--- a/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir
+++ b/clang/test/CIR/Transforms/eh-abi-lowering-construct-catch.cir
@@ -56,7 +56,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E(
}
cir.func @test_basic_construct_catch() {
- %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %0 = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb7
@@ -131,7 +131,7 @@ cir.func linkonce_odr hidden @__clang_cir_catch_copy__ZTS1E_shared(
}
cir.func @test_shared_thunk_caller_a() {
- %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %0 = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb7
@@ -158,7 +158,7 @@ cir.func @test_shared_thunk_caller_a() {
}
cir.func @test_shared_thunk_caller_b() {
- %0 = cir.alloca "e" align(1) !rec_E -> !cir.ptr<!rec_E>
+ %0 = cir.alloca "e" align(1) : !cir.ptr<!rec_E>
cir.try_call @_Z8mayThrowv() ^bb1, ^bb2 : () -> ()
^bb1:
cir.br ^bb7
diff --git a/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir b/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir
index 007fdc5bdd3a0..6e557227c1de7 100644
--- a/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir
+++ b/clang/test/CIR/Transforms/eh-abi-lowering-itanium.cir
@@ -19,7 +19,7 @@ module attributes {cir.triple = "x86_64-unknown-linux-gnu"} {
// cir.begin_cleanup / cir.end_cleanup → removed
// cir.resume → cir.resume.flat
cir.func @test_cleanup_only() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try_call @doSomething(%0) ^bb1, ^bb2 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
@@ -253,7 +253,7 @@ cir.func @test_multiple_typed_and_catch_all() {
// Two landing pads: one without cleanup (ctor), one with cleanup (doSomething).
// cleanup ops are removed, cleanup code stays.
cir.func @test_catch_with_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.try_call @ctor(%0) ^bb1, ^bb3 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
cir.try_call @doSomething(%0) ^bb2, ^bb4 : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -333,7 +333,7 @@ cir.func @test_catch_with_cleanup() {
// Having a typed catch in the dispatch causes both eh.initiate sites to
// include @_ZTISt9exception in their catch_type_list.
cir.func @test_typed_catch_with_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.try_call @ctor(%0) ^bb1, ^bb3 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
cir.try_call @doSomething(%0) ^bb2, ^bb4 : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -427,7 +427,7 @@ cir.func @test_typed_catch_with_cleanup() {
cir.func no_inline dso_local @test_catch_with_cleanup_no_ctor() personality(@__gxx_personality_v0) {
cir.br ^bb1
^bb1: // pred: ^bb0
- %0 = cir.alloca "s" align(1) !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "s" align(1) : !cir.ptr<!rec_SomeClass>
cir.br ^bb2
^bb2: // pred: ^bb1
cir.try_call @mayThrow() ^bb3, ^bb4 : () -> ()
@@ -503,7 +503,7 @@ cir.func no_inline dso_local @test_catch_with_cleanup_no_ctor() personality(@__g
// This represents the case where an exception is thrown during cleanup code
// (e.g., a destructor that throws while another exception is being unwound).
cir.func @test_eh_terminate() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try_call @doSomething(%0) ^bb1, ^bb2 : (!cir.ptr<!rec_SomeClass>) -> ()
^bb1:
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir
index 78b4cd0d8337a..8df7fb042bb52 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-eh.cir
@@ -12,7 +12,7 @@
// exception-throwing calls are replaced with try_call and unwind to an
// EH cleanup block that performs the cleanup and resumes unwinding.
cir.func @test_eh_only_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -25,7 +25,7 @@ cir.func @test_eh_only_cleanup() {
}
// CHECK-LABEL: cir.func @test_eh_only_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -53,7 +53,7 @@ cir.func @test_eh_only_cleanup() {
// Test cleanup kind "all" flattening. Normal exits go through the normal
// cleanup path, and exception-throwing calls unwind to an EH cleanup block.
cir.func @test_all_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -66,7 +66,7 @@ cir.func @test_all_cleanup() {
}
// CHECK-LABEL: cir.func @test_all_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -101,7 +101,7 @@ cir.func @test_all_cleanup() {
// Test EH cleanup with multiple calls that may throw. Each call becomes a
// try_call, and all unwind to the same shared unwind block.
cir.func @test_eh_cleanup_multiple_calls() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -115,7 +115,7 @@ cir.func @test_eh_cleanup_multiple_calls() {
}
// CHECK-LABEL: cir.func @test_eh_cleanup_multiple_calls()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -147,7 +147,7 @@ cir.func @test_eh_cleanup_multiple_calls() {
// Test that nothrow calls are NOT replaced with try_call.
cir.func @test_eh_cleanup_nothrow_call() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -161,7 +161,7 @@ cir.func @test_eh_cleanup_nothrow_call() {
}
// CHECK-LABEL: cir.func @test_eh_cleanup_nothrow_call()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -189,8 +189,8 @@ cir.func @test_eh_cleanup_nothrow_call() {
// Test EH cleanup with a call that returns a value.
cir.func @test_eh_cleanup_call_with_result() -> !s32i {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%2 = cir.call @get() : () -> !s32i
@@ -205,8 +205,8 @@ cir.func @test_eh_cleanup_call_with_result() -> !s32i {
}
// CHECK-LABEL: cir.func @test_eh_cleanup_call_with_result()
-// CHECK: %[[ALLOCA_CLASS:.*]] = cir.alloca {{.*}} !rec_SomeClass
-// CHECK: %[[ALLOCA_RET:.*]] = cir.alloca {{.*}} !s32i
+// CHECK: %[[ALLOCA_CLASS:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_RET:.*]] = cir.alloca {{.*}} : !cir.ptr<!s32i>
// CHECK: cir.call @ctor(%[[ALLOCA_CLASS]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
@@ -236,8 +236,8 @@ cir.func @test_eh_cleanup_call_with_result() -> !s32i {
// Then the cleanup scope flattening must handle cloning the multi-block
// cleanup region for the EH path.
cir.func @test_nrvo() -> !rec_NonTrivial {
- %0 = cir.alloca "__retval" align(1) !rec_NonTrivial -> !cir.ptr<!rec_NonTrivial>
- %1 = cir.alloca "nrvo" align(1) !cir.bool -> !cir.ptr<!cir.bool>
+ %0 = cir.alloca "__retval" align(1) : !cir.ptr<!rec_NonTrivial>
+ %1 = cir.alloca "nrvo" align(1) : !cir.ptr<!cir.bool>
cir.cleanup.scope {
%2 = cir.const #false
cir.store align(1) %2, %1 : !cir.bool, !cir.ptr<!cir.bool>
@@ -258,8 +258,8 @@ cir.func @test_nrvo() -> !rec_NonTrivial {
}
// CHECK-LABEL: cir.func @test_nrvo()
-// CHECK: %[[RETVAL:.*]] = cir.alloca {{.*}} !rec_NonTrivial
-// CHECK: %[[NRVO:.*]] = cir.alloca {{.*}} !cir.bool
+// CHECK: %[[RETVAL:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_NonTrivial>
+// CHECK: %[[NRVO:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.bool>
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
//
// Body: store false to nrvo flag, try_call maybeThrow.
@@ -321,7 +321,7 @@ cir.func @test_nrvo() -> !rec_NonTrivial {
// In this case, the unwind from the EH cleanup can be left to unwind to
// callers.
cir.func @test_eh_cleanup_in_try() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try {
cir.cleanup.scope {
@@ -337,7 +337,7 @@ cir.func @test_eh_cleanup_in_try() {
}
// CHECK: cir.func @test_eh_cleanup_in_try()
-// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[TRY_BODY:bb[0-9]+]]
//
@@ -383,8 +383,8 @@ cir.func @test_eh_cleanup_in_try() {
// doSomething(&c);
// }
cir.func @test_nested_eh_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -404,8 +404,8 @@ cir.func @test_nested_eh_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_eh_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C2:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
//
@@ -488,8 +488,8 @@ cir.func @test_nested_eh_cleanup() {
// }
// };
cir.func @test_nested_eh_only_cleanup() {
- %0 = cir.alloca "base" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "base" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -509,8 +509,8 @@ cir.func @test_nested_eh_only_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_eh_only_cleanup()
-// CHECK: %[[BASE:.*]] = cir.alloca "base" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[BASE:.*]] = cir.alloca "base" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[BASE]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
//
@@ -586,8 +586,8 @@ cir.func @test_nested_eh_only_cleanup() {
// doSomethingElse(&c);
// }
cir.func @test_nested_eh_both_throwing() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -608,8 +608,8 @@ cir.func @test_nested_eh_both_throwing() {
}
// CHECK-LABEL: cir.func @test_nested_eh_both_throwing()
-// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[C2:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
//
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir
index 1b1ca993a2461..c5bfed3e058aa 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-multi-exit.cir
@@ -7,7 +7,7 @@
// Test that a cleanup scope with break that branches through cleanup is
// properly flattened with a destination slot and switch dispatch.
cir.func @test_multi_exit_with_break() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -30,8 +30,8 @@ cir.func @test_multi_exit_with_break() {
}
// CHECK-LABEL: cir.func @test_multi_exit_with_break()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -77,7 +77,7 @@ cir.func private @shouldBreak() -> !cir.bool
// Test that a cleanup scope with continue that branches through cleanup is
// properly flattened.
cir.func @test_multi_exit_with_continue() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -100,8 +100,8 @@ cir.func @test_multi_exit_with_continue() {
}
// CHECK-LABEL: cir.func @test_multi_exit_with_continue()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -144,7 +144,7 @@ cir.func private @shouldContinue() -> !cir.bool
// Test continue inside a switch that's inside a cleanup scope.
cir.func @test_continue_in_switch() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -172,8 +172,8 @@ cir.func @test_continue_in_switch() {
}
// CHECK-LABEL: cir.func @test_continue_in_switch()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -221,7 +221,7 @@ cir.func @test_continue_in_switch() {
// Test return inside a loop inside a switch inside a cleanup scope.
cir.func @test_return_in_loop_in_switch() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -258,8 +258,8 @@ cir.func @test_return_in_loop_in_switch() {
}
// CHECK-LABEL: cir.func @test_return_in_loop_in_switch()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -318,8 +318,8 @@ cir.func private @shouldReturn() -> !cir.bool
// Test return inside nested cleanup scopes - both need multi-exit handling.
cir.func @test_return_in_nested_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -343,9 +343,9 @@ cir.func @test_return_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_return_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -403,8 +403,8 @@ cir.func @test_return_in_nested_cleanup() {
// Test return inside nested cleanup scopes.
cir.func @test_return_constant_in_nested_cleanup() -> !s32i {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -430,9 +430,9 @@ cir.func @test_return_constant_in_nested_cleanup() -> !s32i {
}
// CHECK-LABEL: cir.func @test_return_constant_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -492,8 +492,8 @@ cir.func @test_return_constant_in_nested_cleanup() -> !s32i {
// Test return with computed value.
cir.func @test_return_computed_value(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -520,10 +520,10 @@ cir.func @test_return_computed_value(%arg0: !s32i) -> !s32i {
// CHECK-LABEL: cir.func @test_return_computed_value
// CHECK-SAME: (%[[ARG0:.*]]: !s32i)
-// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} : !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -585,8 +585,8 @@ cir.func @test_return_computed_value(%arg0: !s32i) -> !s32i {
// Test return with of a function parameter value.
cir.func @test_return_param_value(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -612,10 +612,10 @@ cir.func @test_return_param_value(%arg0: !s32i) -> !s32i {
// CHECK-LABEL: cir.func @test_return_param_value
// CHECK-SAME: (%[[ARG0:.*]]: !s32i)
-// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} : !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -676,8 +676,8 @@ cir.func @test_return_param_value(%arg0: !s32i) -> !s32i {
// Test return of a block argument value.
cir.func @test_return_blockarg_value(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -705,10 +705,10 @@ cir.func @test_return_blockarg_value(%arg0: !s32i) -> !s32i {
// CHECK-LABEL: cir.func @test_return_blockarg_value
// CHECK-SAME: (%[[ARG0:.*]]: !s32i)
-// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[RET_TMP:.*]] = cir.alloca "__ret_operand_tmp" {{.*}} : !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} init : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} init : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -771,8 +771,8 @@ cir.func @test_return_blockarg_value(%arg0: !s32i) -> !s32i {
// Test break inside nested cleanup scopes within a loop.
cir.func @test_break_in_nested_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -802,9 +802,9 @@ cir.func @test_break_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_break_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -869,8 +869,8 @@ cir.func @test_break_in_nested_cleanup() {
// Test continue inside nested cleanup scopes within a loop.
cir.func @test_continue_in_nested_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -900,9 +900,9 @@ cir.func @test_continue_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_continue_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -967,9 +967,9 @@ cir.func @test_continue_in_nested_cleanup() {
// Test continue inside nested cleanup in switch.
cir.func @test_continue_in_nested_cleanup_in_switch() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %2 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
+ %2 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
cir.while {
%true = cir.const #cir.bool<true> : !cir.bool
cir.condition(%true)
@@ -1001,10 +1001,10 @@ cir.func @test_continue_in_nested_cleanup_in_switch() {
}
// CHECK-LABEL: cir.func @test_continue_in_nested_cleanup_in_switch()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_X:.*]] = cir.alloca "x" {{.*}} !s32i -> !cir.ptr<!s32i>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_X:.*]] = cir.alloca "x" {{.*}} : !cir.ptr<!s32i>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[TRUE:.*]] = cir.const #true
@@ -1057,7 +1057,7 @@ cir.func @test_continue_in_nested_cleanup_in_switch() {
// Test return inside loop inside cleanup scope.
cir.func @test_return_in_loop_in_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.while {
@@ -1080,8 +1080,8 @@ cir.func @test_return_in_loop_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_return_in_loop_in_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[CLEANUP_BODY:bb[0-9]+]]
// CHECK: ^[[CLEANUP_BODY]]:
@@ -1128,7 +1128,7 @@ cir.func private @shouldGoto() -> !cir.bool
// switch routes the goto's destination id to a block containing a new
// cir.goto to the same label.
cir.func @test_multi_exit_with_goto() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%cond = cir.call @shouldGoto() : () -> !cir.bool
@@ -1148,8 +1148,8 @@ cir.func @test_multi_exit_with_goto() {
}
// CHECK-LABEL: cir.func @test_multi_exit_with_goto()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -1188,8 +1188,8 @@ cir.func @test_multi_exit_with_goto() {
// scopes. The goto must branch through both cleanups before reaching its
// target. Each cleanup re-emits the goto via its dispatch destination block.
cir.func @test_goto_in_nested_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -1218,9 +1218,9 @@ cir.func @test_goto_in_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_in_nested_cleanup()
-// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot !s32i -> !cir.ptr<!s32i>
-// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
-// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+// CHECK: %[[DEST_SLOT:.*]] = cir.alloca "__cleanup_dest_slot" {{.*}} cleanup_dest_slot : !cir.ptr<!s32i>
+// CHECK: %[[ALLOCA_C1:.*]] = cir.alloca "c1" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA_C2:.*]] = cir.alloca "c2" {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA_C1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
diff --git a/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir b/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
index 49a889d753e6e..7209c04c44578 100644
--- a/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
+++ b/clang/test/CIR/Transforms/flatten-cleanup-scope-simple.cir
@@ -7,7 +7,7 @@
// Test basic cleanup scope flattening with normal cleanup.
// The body yields to cleanup, cleanup yields to continue.
cir.func @test_normal_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -20,7 +20,7 @@ cir.func @test_normal_cleanup() {
}
// CHECK-LABEL: cir.func @test_normal_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -34,7 +34,7 @@ cir.func @test_normal_cleanup() {
// Test that a single return from the cleanup body branches through the cleanup.
cir.func @test_return_from_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -47,7 +47,7 @@ cir.func @test_return_from_cleanup() {
}
// CHECK-LABEL: cir.func @test_return_from_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -63,7 +63,7 @@ cir.func @test_return_from_cleanup() {
// Test that a single return from the cleanup body branches through the cleanup.
cir.func @test_return_from_cleanup_with_operand() -> !s32i {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -78,7 +78,7 @@ cir.func @test_return_from_cleanup_with_operand() -> !s32i {
}
// CHECK-LABEL: cir.func @test_return_from_cleanup_with_operand()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -97,7 +97,7 @@ cir.func @test_return_from_cleanup_with_operand() -> !s32i {
// Test that a continue statement in a cleanup scope branches through the
// cleanup block before continuing the loop.
cir.func @test_continue_in_cleanup_in_loop() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%cond = cir.call @shouldContinue() : () -> !cir.bool
cir.condition(%cond)
@@ -120,7 +120,7 @@ cir.func @test_continue_in_cleanup_in_loop() {
}
// CHECK-LABEL: cir.func @test_continue_in_cleanup_in_loop()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[COND1:.*]] = cir.call @shouldContinue() : () -> !cir.bool
@@ -146,7 +146,7 @@ cir.func @test_continue_in_cleanup_in_loop() {
// Test that a break statement in a cleanup scope branches through the
// cleanup block before breaking out of the loop.
cir.func @test_break_in_cleanup_in_loop() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.while {
%cond = cir.call @shouldContinue() : () -> !cir.bool
cir.condition(%cond)
@@ -169,7 +169,7 @@ cir.func @test_break_in_cleanup_in_loop() {
}
// CHECK-LABEL: cir.func @test_break_in_cleanup_in_loop()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[LOOP_COND:bb[0-9]+]]
// CHECK: ^[[LOOP_COND]]:
// CHECK: %[[COND1:.*]] = cir.call @shouldContinue() : () -> !cir.bool
@@ -194,8 +194,8 @@ cir.func @test_break_in_cleanup_in_loop() {
// Test nested cleanup scopes.
cir.func @test_nested_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -215,8 +215,8 @@ cir.func @test_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_cleanup()
-// CHECK: %[[ALLOCA1:.*]] = cir.alloca {{.*}} !rec_SomeClass
-// CHECK: %[[ALLOCA2:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA1:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA2:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -239,7 +239,7 @@ cir.func @test_nested_cleanup() {
// Test a switch within a cleanup scope where the switch does not branch
// through the cleanup.
cir.func @test_normal_cleanup_with_switch() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%1 = cir.call @get() : () -> !s32i
@@ -262,7 +262,7 @@ cir.func @test_normal_cleanup_with_switch() {
}
// CHECK-LABEL: cir.func @test_normal_cleanup_with_switch()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -292,7 +292,7 @@ cir.func @test_normal_cleanup_with_switch() {
// handled by the loop itself, so only the yield after the loop exits through
// the cleanup.
cir.func @test_loop_in_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.while {
@@ -315,7 +315,7 @@ cir.func @test_loop_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_loop_in_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[LOOP_BEGIN:bb[0-9]+]]
// CHECK: ^[[LOOP_BEGIN]]:
@@ -342,7 +342,7 @@ cir.func @test_loop_in_cleanup() {
// handled by the switch, the loop's break/continue are handled by the loop,
// so only the yield exits through cleanup.
cir.func @test_switch_in_loop_in_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.while {
@@ -370,7 +370,7 @@ cir.func @test_switch_in_loop_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_switch_in_loop_in_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[LOOP_BEGIN:bb[0-9]+]]
// CHECK: ^[[LOOP_BEGIN]]:
@@ -404,7 +404,7 @@ cir.func @test_switch_in_loop_in_cleanup() {
// are handled by the loop, the switch's break exits the switch, so only the
// yield exits through cleanup.
cir.func @test_loop_in_switch_in_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%x = cir.call @get() : () -> !s32i
@@ -434,7 +434,7 @@ cir.func @test_loop_in_switch_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_loop_in_switch_in_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -472,8 +472,8 @@ cir.func @test_loop_in_switch_in_cleanup() {
// scope with a break. The break is handled by the switch, so the outer cleanup
// has only one exit (yield) and should flatten successfully.
cir.func @test_nested_cleanup_break_in_switch() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%x = cir.call @get() : () -> !s32i
@@ -500,8 +500,8 @@ cir.func @test_nested_cleanup_break_in_switch() {
}
// CHECK-LABEL: cir.func @test_nested_cleanup_break_in_switch()
-// CHECK: %[[ALLOCA1:.*]] = cir.alloca {{.*}} !rec_SomeClass
-// CHECK: %[[ALLOCA2:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA1:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[ALLOCA2:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA1]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -537,7 +537,7 @@ cir.func @test_nested_cleanup_break_in_switch() {
// the yield at the end of the body, so the cleanup runs once after the goto's
// destination is reached.
cir.func @test_goto_within_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
%cond = cir.call @shouldGoto() : () -> !cir.bool
@@ -558,7 +558,7 @@ cir.func @test_goto_within_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_within_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
@@ -583,8 +583,8 @@ cir.func @test_goto_within_cleanup() {
// exit; the inner cleanup runs once after the goto's destination is reached
// and the outer cleanup runs once on normal exit from the inner cleanup.
cir.func @test_goto_within_nested_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -612,8 +612,8 @@ cir.func @test_goto_within_nested_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_within_nested_cleanup()
-// CHECK: %[[A1:.*]] = cir.alloca "c1" {{.*}} !rec_SomeClass
-// CHECK: %[[A2:.*]] = cir.alloca "c2" {{.*}} !rec_SomeClass
+// CHECK: %[[A1:.*]] = cir.alloca "c1" {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[A2:.*]] = cir.alloca "c2" {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[A1]])
// CHECK: cir.br ^[[OUTER_BODY:bb[0-9]+]]
// CHECK: ^[[OUTER_BODY]]:
@@ -646,7 +646,7 @@ cir.func @test_goto_within_nested_cleanup() {
// body branches to cleanup entry, the cleanup runs and then a goto with the
// same target label is emitted in the cleanup continuation block.
cir.func @test_goto_out_of_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -662,7 +662,7 @@ cir.func @test_goto_out_of_cleanup() {
}
// CHECK-LABEL: cir.func @test_goto_out_of_cleanup()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[ALLOCA]])
// CHECK: cir.br ^[[BODY:bb[0-9]+]]
// CHECK: ^[[BODY]]:
diff --git a/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir b/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir
index 26da1238ec2cd..a563300f8c768 100644
--- a/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir
+++ b/clang/test/CIR/Transforms/flatten-throwing-in-cleanup.cir
@@ -8,7 +8,7 @@
// Test that a throwing call in an EH cleanup region is replaced with
// cir.try_call that unwinds to a terminate block.
cir.func @test_throwing_dtor_in_eh_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -55,7 +55,7 @@ cir.func @test_throwing_dtor_in_eh_cleanup() {
// On the EH cleanup path, the call is replaced with try_call → terminate.
// On the normal cleanup path, the call remains a regular cir.call.
cir.func @test_throwing_dtor_in_all_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.call @doSomething(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -95,7 +95,7 @@ cir.func @test_throwing_dtor_in_all_cleanup() {
// Test throwing call in EH cleanup within a try operation.
cir.func @test_throwing_dtor_in_eh_cleanup_in_try() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.try {
cir.cleanup.scope {
@@ -130,8 +130,8 @@ cir.func @test_throwing_dtor_in_eh_cleanup_in_try() {
// Test multiple throwing calls in the cleanup region.
cir.func @test_multiple_throwing_calls_in_cleanup() {
- %0 = cir.alloca "c1" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "c2" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c1" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "c2" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.call @ctor(%1) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
diff --git a/clang/test/CIR/Transforms/flatten-try-op.cir b/clang/test/CIR/Transforms/flatten-try-op.cir
index 580849aa183fc..8c1127c35390b 100644
--- a/clang/test/CIR/Transforms/flatten-try-op.cir
+++ b/clang/test/CIR/Transforms/flatten-try-op.cir
@@ -9,7 +9,7 @@
// Test a simple try with no handlers and no throwing calls.
cir.func @test_try_no_handlers() {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.scope {
cir.try {
%1 = cir.const #cir.int<1> : !s32i
@@ -21,7 +21,7 @@ cir.func @test_try_no_handlers() {
}
// CHECK-LABEL: cir.func @test_try_no_handlers()
-// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} !s32i
+// CHECK: %[[ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!s32i>
// CHECK: cir.br ^[[SCOPE:bb[0-9]+]]
// CHECK: ^[[SCOPE]]:
// CHECK: cir.br ^[[TRY_BODY:bb[0-9]+]]
@@ -86,7 +86,7 @@ cir.func @test_try_catch_all() {
// If the exception type doesn't match, control goes to the unwind handler
// which resumes unwinding.
cir.func @test_try_catch_typed_with_unwind() {
- %0 = cir.alloca "e" align(8) !cir.ptr<!rec_exception> -> !cir.ptr<!cir.ptr<!rec_exception>>
+ %0 = cir.alloca "e" align(8) : !cir.ptr<!cir.ptr<!rec_exception>>
cir.scope {
cir.try {
cir.call @mayThrow() : () -> ()
@@ -103,7 +103,7 @@ cir.func @test_try_catch_typed_with_unwind() {
}
// CHECK-LABEL: cir.func @test_try_catch_typed_with_unwind()
-// CHECK: %[[E_ALLOCA:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_std3A3Aexception>
+// CHECK: %[[E_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!rec_std3A3Aexception>>
// CHECK: cir.br ^[[SCOPE:bb[0-9]+]]
//
// CHECK: ^[[SCOPE]]:
@@ -142,7 +142,7 @@ cir.func @test_try_catch_typed_with_unwind() {
// are chained to the catch dispatch block of the enclosing try.
cir.func @test_try_catch_with_cleanup() {
cir.scope {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.try {
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
@@ -163,7 +163,7 @@ cir.func @test_try_catch_with_cleanup() {
}
// CHECK-LABEL: cir.func @test_try_catch_with_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[TRY_BODY:bb[0-9]+]]
//
// CHECK: ^[[TRY_BODY]]:
@@ -221,8 +221,8 @@ cir.func @test_try_catch_with_cleanup() {
// by the try's handlers, the resume from the unwind handler should chain
// to the outer cleanup's EH handler.
cir.func @test_try_in_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
- %1 = cir.alloca "e" align(8) !cir.ptr<!rec_exception> -> !cir.ptr<!cir.ptr<!rec_exception>>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
+ %1 = cir.alloca "e" align(8) : !cir.ptr<!cir.ptr<!rec_exception>>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.scope {
@@ -246,8 +246,8 @@ cir.func @test_try_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_try_in_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
-// CHECK: %[[E:.*]] = cir.alloca {{.*}} !cir.ptr<!rec_std3A3Aexception>
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
+// CHECK: %[[E:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.ptr<!rec_std3A3Aexception>>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[OUTER_CLEANUP_BODY:bb[0-9]+]]
//
@@ -473,7 +473,7 @@ cir.func @test_nested_try() {
// scope inside a catch handler. This is the form of the catch handler that will
// actually be generated. The representations above are all simplifications.
cir.func @test_try_with_handlers_in_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
cir.cleanup.scope {
cir.try {
@@ -498,7 +498,7 @@ cir.func @test_try_with_handlers_in_cleanup() {
}
// CHECK-LABEL: cir.func @test_try_with_handlers_in_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.call @ctor(%[[C]])
// CHECK: cir.br ^[[CLEANUP_BODY:bb[0-9]+]]
//
@@ -543,7 +543,7 @@ cir.func @test_try_with_handlers_in_cleanup() {
// The inner try's unwind handler must execute the cleanup (dtor) before
// the exception reaches the outer try's catch dispatch.
cir.func @test_nested_try_with_cleanup() {
- %0 = cir.alloca "c" align(4) init !rec_SomeClass -> !cir.ptr<!rec_SomeClass>
+ %0 = cir.alloca "c" align(4) init : !cir.ptr<!rec_SomeClass>
cir.scope {
cir.try {
cir.call @ctor(%0) : (!cir.ptr<!rec_SomeClass>) -> ()
@@ -574,7 +574,7 @@ cir.func @test_nested_try_with_cleanup() {
}
// CHECK-LABEL: cir.func @test_nested_try_with_cleanup()
-// CHECK: %[[C:.*]] = cir.alloca {{.*}} !rec_SomeClass
+// CHECK: %[[C:.*]] = cir.alloca {{.*}} : !cir.ptr<!rec_SomeClass>
// CHECK: cir.br ^[[SCOPE:bb[0-9]+]]
//
// CHECK: ^[[SCOPE]]:
diff --git a/clang/test/CIR/Transforms/goto_solver.cir b/clang/test/CIR/Transforms/goto_solver.cir
index b41f498ec33db..31ee10b70f613 100644
--- a/clang/test/CIR/Transforms/goto_solver.cir
+++ b/clang/test/CIR/Transforms/goto_solver.cir
@@ -3,7 +3,7 @@
!void = !cir.void
cir.func @a(){
- %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %0 = cir.alloca "ptr" align(8) init : !cir.ptr<!cir.ptr<!void>>
%1 = cir.block_address <@a, "label1"> : !cir.ptr<!void>
cir.store align(8) %1, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
cir.br ^bb1
@@ -25,7 +25,7 @@ cir.func @a(){
// CHECK-NOT: cir.label "label2"
cir.func @b(){
- %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %0 = cir.alloca "ptr" align(8) init : !cir.ptr<!cir.ptr<!void>>
%1 = cir.block_address <@b, "label1"> : !cir.ptr<!void>
cir.store align(8) %1, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
cir.goto "label2"
@@ -50,7 +50,7 @@ cir.func @b(){
cir.func @c() {
cir.label "label1"
- %0 = cir.alloca "ptr" align(8) init !cir.ptr<!void> -> !cir.ptr<!cir.ptr<!void>>
+ %0 = cir.alloca "ptr" align(8) init : !cir.ptr<!cir.ptr<!void>>
%1 = cir.block_address <@c, "label1"> : !cir.ptr<!void>
cir.store align(8) %1, %0 : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
cir.return
diff --git a/clang/test/CIR/Transforms/hoist-allocas.cir b/clang/test/CIR/Transforms/hoist-allocas.cir
index b0a8b15e00aa8..6c71c00532f56 100644
--- a/clang/test/CIR/Transforms/hoist-allocas.cir
+++ b/clang/test/CIR/Transforms/hoist-allocas.cir
@@ -6,7 +6,7 @@
module {
cir.func @l1() {
cir.scope {
- %0 = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
%1 = cir.const #cir.int<0> : !s32i
cir.store %1, %0 : !s32i, !cir.ptr<!s32i>
cir.for : cond {
@@ -21,7 +21,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @l1
- // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.store %[[ZERO]], %[[I]] : !s32i, !cir.ptr<!s32i>
@@ -44,7 +44,7 @@ module {
cir.condition(%0)
} body {
cir.scope {
- %1 = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
%2 = cir.const #cir.int<0> : !s32i
cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
}
@@ -56,7 +56,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @l2
- // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
@@ -81,7 +81,7 @@ module {
cir.condition(%0)
} body {
cir.scope {
- %1 = cir.alloca "i" align(4) init const !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "i" align(4) init const : !cir.ptr<!s32i>
%2 = cir.const #cir.int<0> : !s32i
cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
}
@@ -93,7 +93,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @l3
- // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CHECK-NEXT: cir.scope {
// CHECK-NEXT: cir.for : cond {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
diff --git a/clang/test/CIR/Transforms/mem2reg.cir b/clang/test/CIR/Transforms/mem2reg.cir
index 87d9b970e4b4b..2319de275700c 100644
--- a/clang/test/CIR/Transforms/mem2reg.cir
+++ b/clang/test/CIR/Transforms/mem2reg.cir
@@ -11,8 +11,8 @@ module {
cir.func @promote_simple_stack_slots() -> !s32i {
// CHECK: %[[CONST:.*]] = cir.const #cir.int<42>
// CHECK: cir.return %[[CONST]]
- %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+ %1 = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
%2 = cir.const #cir.int<42> : !s32i
cir.store %2, %1 : !s32i, !cir.ptr<!s32i>
%3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/scope.cir b/clang/test/CIR/Transforms/scope.cir
index 22bfdb246ba70..0c07d924a523a 100644
--- a/clang/test/CIR/Transforms/scope.cir
+++ b/clang/test/CIR/Transforms/scope.cir
@@ -5,7 +5,7 @@
module {
cir.func @foo() {
cir.scope {
- %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
%1 = cir.const #cir.int<4> : !u32i
cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
}
@@ -14,7 +14,7 @@ module {
// CHECK: cir.func{{.*}} @foo() {
// CHECK: cir.br ^bb1
// CHECK: ^bb1: // pred: ^bb0
-// CHECK: %0 = cir.alloca "a" align(4) init !u32i -> !cir.ptr<!u32i>
+// CHECK: %0 = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
// CHECK: %1 = cir.const #cir.int<4> : !u32i
// CHECK: cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
// CHECK: cir.br ^bb2
@@ -33,7 +33,7 @@ module {
// CHECK: }
cir.func @scope_with_return() -> !u32i {
- %0 = cir.alloca "__retval" align(4) !u32i -> !cir.ptr<!u32i>
+ %0 = cir.alloca "__retval" align(4) : !cir.ptr<!u32i>
cir.scope {
%2 = cir.const #cir.int<0> : !u32i
cir.store %2, %0 : !u32i, !cir.ptr<!u32i>
@@ -45,7 +45,7 @@ module {
}
// CHECK: cir.func{{.*}} @scope_with_return() -> !u32i {
-// CHECK: %0 = cir.alloca "__retval" align(4) !u32i -> !cir.ptr<!u32i>
+// CHECK: %0 = cir.alloca "__retval" align(4) : !cir.ptr<!u32i>
// CHECK: cir.br ^bb1
// CHECK: ^bb1: // pred: ^bb0
// CHECK: %1 = cir.const #cir.int<0> : !u32i
diff --git a/clang/test/CIR/Transforms/switch-fold.cir b/clang/test/CIR/Transforms/switch-fold.cir
index 7b4e59718ec86..6757a861265bd 100644
--- a/clang/test/CIR/Transforms/switch-fold.cir
+++ b/clang/test/CIR/Transforms/switch-fold.cir
@@ -5,7 +5,7 @@
module {
cir.func @foldCascade(%arg0: !s32i) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -37,7 +37,7 @@ module {
//CHECK-NEXT: }
cir.func @foldCascade2(%arg0: !s32i) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -76,10 +76,10 @@ module {
//CHECK: cir.yield
//CHECK: }
cir.func @foldCascade3(%arg0: !s32i ) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
- %1 = cir.alloca "x" align(4) !s32i -> !cir.ptr<!s32i>
+ %1 = cir.alloca "x" align(4) : !cir.ptr<!s32i>
%2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
cir.switch (%2 : !s32i) {
cir.case(equal, [#cir.int<0> : !s32i]) {
@@ -113,7 +113,7 @@ module {
//CHECK: cir.yield
//CHECK: }
cir.func @foldCascadeWithDefault(%arg0: !s32i ) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -158,7 +158,7 @@ module {
//CHECK: cir.yield
//CHECK: }
cir.func @foldAllCascade(%arg0: !s32i ) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/switch.cir b/clang/test/CIR/Transforms/switch.cir
index 2a96c60896be5..0ac323800a7fb 100644
--- a/clang/test/CIR/Transforms/switch.cir
+++ b/clang/test/CIR/Transforms/switch.cir
@@ -127,7 +127,7 @@ module {
cir.func @shouldFlatMultiBlockCase(%arg0: !s32i) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -144,7 +144,7 @@ module {
}
// CHECK: cir.func{{.*}} @shouldFlatMultiBlockCase(%arg0: !s32i) {
-// CHECK: %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: cir.br ^bb1
// CHECK: ^bb1: // pred: ^bb0
@@ -162,9 +162,9 @@ module {
cir.func @shouldFlatNestedBreak(%arg0: !s32i, %arg1: !s32i) -> !s32i {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
- %2 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
+ %2 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
cir.scope {
@@ -211,9 +211,9 @@ module {
cir.func @flatCaseRange(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca "x" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
- %2 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+ %2 = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
%3 = cir.const #cir.int<0> : !s32i
cir.store %3, %2 : !s32i, !cir.ptr<!s32i>
@@ -275,7 +275,7 @@ module {
// CHECK: }
cir.func @_Z8bigRangei(%arg0: !s32i) {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
cir.scope {
%1 = cir.load %0 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/ternary-fold.cir b/clang/test/CIR/Transforms/ternary-fold.cir
index 245cd01e7d35c..fa5520cabd91b 100644
--- a/clang/test/CIR/Transforms/ternary-fold.cir
+++ b/clang/test/CIR/Transforms/ternary-fold.cir
@@ -51,7 +51,7 @@ module {
// CHECK-NEXT: }
cir.func @non_simplifiable_ternary(%arg0 : !cir.bool) -> !s32i {
- %0 = cir.alloca "a" align(4) init !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
%1 = cir.ternary (%arg0, true {
%2 = cir.const #cir.int<42> : !s32i
cir.yield %2 : !s32i
@@ -63,7 +63,7 @@ module {
}
// CHECK: cir.func{{.*}} @non_simplifiable_ternary(%[[ARG0:.+]]: !cir.bool) -> !s32i {
- // CHECK-NEXT: %[[#A:]] = cir.alloca "a" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK-NEXT: %[[#A:]] = cir.alloca "a" {{.*}} init : !cir.ptr<!s32i>
// CHECK-NEXT: %[[#B:]] = cir.ternary(%[[ARG0]], true {
// CHECK-NEXT: %[[#C:]] = cir.const #cir.int<42> : !s32i
// CHECK-NEXT: cir.yield %[[#C]] : !s32i
diff --git a/clang/test/CIR/Transforms/ternary.cir b/clang/test/CIR/Transforms/ternary.cir
index 20a5c9edb476a..f50561e7d5b3e 100644
--- a/clang/test/CIR/Transforms/ternary.cir
+++ b/clang/test/CIR/Transforms/ternary.cir
@@ -4,8 +4,8 @@
module {
cir.func @foo(%arg0: !s32i) -> !s32i {
- %0 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
- %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+ %0 = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
%2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
%3 = cir.const #cir.int<0> : !s32i
@@ -23,8 +23,8 @@ module {
}
// CHECK: cir.func{{.*}} @foo(%arg0: !s32i) -> !s32i {
-// CHECK: %0 = cir.alloca "y" align(4) init !s32i -> !cir.ptr<!s32i>
-// CHECK: %1 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
+// CHECK: %1 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
// CHECK: %3 = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/Transforms/vector-extract-fold.cir b/clang/test/CIR/Transforms/vector-extract-fold.cir
index 8f88c332ff1bd..2e71b5bf0bbca 100644
--- a/clang/test/CIR/Transforms/vector-extract-fold.cir
+++ b/clang/test/CIR/Transforms/vector-extract-fold.cir
@@ -4,7 +4,7 @@
module {
cir.func @fold_extract_vector_op_test() {
- %init = cir.alloca "e" align(4) init !s32i -> !cir.ptr<!s32i>
+ %init = cir.alloca "e" align(4) init : !cir.ptr<!s32i>
%const_vec = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
%index = cir.const #cir.int<1> : !s32i
%ele = cir.vec.extract %const_vec[%index : !s32i] : !cir.vector<4 x !s32i>
@@ -12,12 +12,12 @@ module {
cir.return
}
- // CHECK: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[VALUE:.*]] = cir.const #cir.int<2> : !s32i
// CHECK: cir.store %[[VALUE]], %[[INIT]] : !s32i, !cir.ptr<!s32i>
cir.func @fold_extract_vector_op_index_out_of_bounds_test() {
- %init = cir.alloca "e" align(4) init !s32i -> !cir.ptr<!s32i>
+ %init = cir.alloca "e" align(4) init : !cir.ptr<!s32i>
%const_vec = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
%index = cir.const #cir.int<9> : !s32i
%ele = cir.vec.extract %const_vec[%index : !s32i] : !cir.vector<4 x !s32i>
@@ -25,7 +25,7 @@ module {
cir.return
}
- // CHECK: %[[INIT:.*]] = cir.alloca "e" {{.*}} init !s32i -> !cir.ptr<!s32i>
+ // CHECK: %[[INIT:.*]] = cir.alloca "e" {{.*}} init : !cir.ptr<!s32i>
// CHECK: %[[CONST_VEC:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK: %[[INDEX:.*]] = cir.const #cir.int<9> : !s32i
// CHECK: %[[ELE:.*]] = cir.vec.extract %[[CONST_VEC]][%[[INDEX]] : !s32i] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/func-simple.cpp b/clang/test/CIR/func-simple.cpp
index 3a32703bd4c58..801f8cb4e7f01 100644
--- a/clang/test/CIR/func-simple.cpp
+++ b/clang/test/CIR/func-simple.cpp
@@ -13,7 +13,7 @@ void voidret() { return; }
int intfunc() { return 42; }
// CHECK: cir.func{{.*}} @_Z7intfuncv() -> (!s32i {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CHECK: %1 = cir.const #cir.int<42> : !s32i
// CHECK: cir.store %1, %0 : !s32i, !cir.ptr<!s32i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!s32i>, !s32i
@@ -28,7 +28,7 @@ int scopes() {
}
}
// CHECK: cir.func{{.*}} @_Z6scopesv() -> (!s32i {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(4) !s32i -> !cir.ptr<!s32i>
+// CHECK: %0 = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CHECK: cir.scope {
// CHECK: cir.scope {
// CHECK: %1 = cir.const #cir.int<99> : !s32i
@@ -42,7 +42,7 @@ int scopes() {
long longfunc() { return 42l; }
// CHECK: cir.func{{.*}} @_Z8longfuncv() -> (!s64i {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(8) !s64i -> !cir.ptr<!s64i>
+// CHECK: %0 = cir.alloca "__retval" align(8) : !cir.ptr<!s64i>
// CHECK: %1 = cir.const #cir.int<42> : !s64i
// CHECK: cir.store %1, %0 : !s64i, !cir.ptr<!s64i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!s64i>, !s64i
@@ -51,7 +51,7 @@ long longfunc() { return 42l; }
unsigned unsignedfunc() { return 42u; }
// CHECK: cir.func{{.*}} @_Z12unsignedfuncv() -> (!u32i {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(4) !u32i -> !cir.ptr<!u32i>
+// CHECK: %0 = cir.alloca "__retval" align(4) : !cir.ptr<!u32i>
// CHECK: %1 = cir.const #cir.int<42> : !u32i
// CHECK: cir.store %1, %0 : !u32i, !cir.ptr<!u32i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!u32i>, !u32i
@@ -60,7 +60,7 @@ unsigned unsignedfunc() { return 42u; }
unsigned long long ullfunc() { return 42ull; }
// CHECK: cir.func{{.*}} @_Z7ullfuncv() -> (!u64i {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(8) !u64i -> !cir.ptr<!u64i>
+// CHECK: %0 = cir.alloca "__retval" align(8) : !cir.ptr<!u64i>
// CHECK: %1 = cir.const #cir.int<42> : !u64i
// CHECK: cir.store %1, %0 : !u64i, !cir.ptr<!u64i>
// CHECK: %2 = cir.load %0 : !cir.ptr<!u64i>, !u64i
@@ -69,7 +69,7 @@ unsigned long long ullfunc() { return 42ull; }
bool boolfunc() { return true; }
// CHECK: cir.func{{.*}} @_Z8boolfuncv() -> (!cir.bool {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(1) !cir.bool -> !cir.ptr<!cir.bool>
+// CHECK: %0 = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CHECK: %1 = cir.const #true
// CHECK: cir.store %1, %0 : !cir.bool, !cir.ptr<!cir.bool>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.bool>, !cir.bool
@@ -78,7 +78,7 @@ bool boolfunc() { return true; }
float floatfunc() { return 42.42f; }
// CHECK: cir.func{{.*}} @_Z9floatfuncv() -> (!cir.float {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(4) !cir.float -> !cir.ptr<!cir.float>
+// CHECK: %0 = cir.alloca "__retval" align(4) : !cir.ptr<!cir.float>
// CHECK: %1 = cir.const #cir.fp<4.242
// CHECK: cir.store %1, %0 : !cir.float, !cir.ptr<!cir.float>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.float>, !cir.float
@@ -87,7 +87,7 @@ float floatfunc() { return 42.42f; }
double doublefunc() { return 42.42; }
// CHECK: cir.func{{.*}} @_Z10doublefuncv() -> (!cir.double {llvm.noundef})
-// CHECK: %0 = cir.alloca "__retval" align(8) !cir.double -> !cir.ptr<!cir.double>
+// CHECK: %0 = cir.alloca "__retval" align(8) : !cir.ptr<!cir.double>
// CHECK: %1 = cir.const #cir.fp<4.242
// CHECK: cir.store %1, %0 : !cir.double, !cir.ptr<!cir.double>
// CHECK: %2 = cir.load %0 : !cir.ptr<!cir.double>, !cir.double
diff --git a/clang/unittests/CIR/PointerLikeTest.cpp b/clang/unittests/CIR/PointerLikeTest.cpp
index bb38860a64cdf..952bf67421470 100644
--- a/clang/unittests/CIR/PointerLikeTest.cpp
+++ b/clang/unittests/CIR/PointerLikeTest.cpp
@@ -76,7 +76,7 @@ class CIROpenACCPointerLikeTest : public ::testing::Test {
EXPECT_EQ(pltTy.getElementType(), ty);
OwningOpRef<cir::AllocaOp> varPtrOp =
- cir::AllocaOp::create(b, loc, ptrTy, ty, "", getAlignOne(&context));
+ cir::AllocaOp::create(b, loc, ptrTy, "", getAlignOne(&context));
mlir::Value val = varPtrOp.get();
mlir::acc::VariableTypeCategory typeCategory = pltTy.getPointeeTypeCategory(
@@ -110,7 +110,7 @@ class CIROpenACCPointerLikeTest : public ::testing::Test {
// Create an alloca for the array
OwningOpRef<cir::AllocaOp> varPtrOp =
- cir::AllocaOp::create(b, loc, ptrTy, arrTy, "", getAlignOne(&context));
+ cir::AllocaOp::create(b, loc, ptrTy, "", getAlignOne(&context));
// Verify that the type category is array.
mlir::Value val = varPtrOp.get();
@@ -178,8 +178,8 @@ class CIROpenACCPointerLikeTest : public ::testing::Test {
EXPECT_EQ(pltTy.getElementType(), structTy);
// Create an alloca for the array
- OwningOpRef<cir::AllocaOp> varPtrOp = cir::AllocaOp::create(
- b, loc, ptrTy, structTy, "", getAlignOne(&context));
+ OwningOpRef<cir::AllocaOp> varPtrOp =
+ cir::AllocaOp::create(b, loc, ptrTy, "", getAlignOne(&context));
// Verify that the type category is composite.
mlir::Value val = varPtrOp.get();
@@ -255,8 +255,8 @@ class CIROpenACCPointerLikeTest : public ::testing::Test {
mlir::Type structPptrTy = cir::PointerType::get(structTy);
// Create an alloca for the struct.
- OwningOpRef<cir::AllocaOp> varPtrOp = cir::AllocaOp::create(
- b, loc, structPptrTy, structTy, "S", getAlignOne(&context));
+ OwningOpRef<cir::AllocaOp> varPtrOp =
+ cir::AllocaOp::create(b, loc, structPptrTy, "S", getAlignOne(&context));
mlir::Value val = varPtrOp.get();
// Get a pointer to the second member.
>From 2801b6ee29aebc2a4cf414e74a0382eee68db4c2 Mon Sep 17 00:00:00 2001
From: Andres Salamanca <andrealebarbaritos at gmail.com>
Date: Wed, 3 Jun 2026 23:09:48 -0500
Subject: [PATCH 7/7] fix after rebase
---
.../TargetLowering/CIRABIRewriteContext.cpp | 2 +-
clang/test/CIR/CodeGen/cleanup-conditional.cpp | 18 +++++++++---------
.../CodeGen/cleanup-derived-to-base-ref.cpp | 6 +++---
clang/test/CIR/CodeGen/complex-atomic-cast.c | 6 +++---
clang/test/CIR/CodeGen/coro-exceptions.cpp | 2 +-
clang/test/CIR/CodeGen/switch-cleanup.cpp | 8 ++++----
clang/test/CIR/CodeGen/vla.c | 6 +++---
.../address-space-local-var.clcpp | 6 +++---
clang/test/CIR/CodeGenOpenCL/as_type.cl | 4 ++--
clang/test/CIR/IR/lifetime.cir | 2 +-
clang/test/CIR/Lowering/lifetime.cir | 2 +-
.../abi-lowering/coerce-int-to-record.cir | 4 ++--
.../coerce-record-return-larger.cir | 4 ++--
.../abi-lowering/coerce-record-to-int.cir | 8 ++++----
.../coerce-record-to-record-via-memory.cir | 8 ++++----
.../abi-lowering/coerce-vector-to-complex.cir | 4 ++--
16 files changed, 45 insertions(+), 45 deletions(-)
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
index a559da51d4958..a2615394f223a 100644
--- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRABIRewriteContext.cpp
@@ -213,7 +213,7 @@ Value emitCoercion(OpBuilder &rewriter, Location loc, Type dstTy, Value src,
OpBuilder::InsertionGuard guard(rewriter);
Block &entry = funcOp->getRegion(0).front();
rewriter.setInsertionPointToStart(&entry);
- alloca = cir::AllocaOp::create(rewriter, loc, slotPtrTy, slotTy,
+ alloca = cir::AllocaOp::create(rewriter, loc, slotPtrTy,
rewriter.getStringAttr("coerce"),
rewriter.getI64IntegerAttr(allocaAlign));
}
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional.cpp b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
index 0c26b7ab8aed6..6afaed51a9d4a 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
@@ -884,9 +884,9 @@ void test_lifetime_ext_cond_ref(bool c) {
const LE &r = c ? LE(1) : LE(2);
}
// CIR-LABEL: @_Z26test_lifetime_ext_cond_refb
-// CIR: %[[TMP:.*]] = cir.alloca !rec_LE, !cir.ptr<!rec_LE>, ["ref.tmp0"]
-// CIR: %[[R:.*]] = cir.alloca !cir.ptr<!rec_LE>, !cir.ptr<!cir.ptr<!rec_LE>>, ["r", init, const]
-// CIR: %[[SPILL:.*]] = cir.alloca !cir.ptr<!rec_LE>, !cir.ptr<!cir.ptr<!rec_LE>>, ["tmp.exprcleanup"]
+// CIR: %[[TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_LE>
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_LE>>
+// CIR: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.ptr<!rec_LE>>
// CIR: cir.if %{{.*}} {
// CIR: cir.call @_ZN2LEC1Ei(%[[TMP]], %{{.*}})
// CIR: } else {
@@ -934,12 +934,12 @@ void test_combined_cleanups(bool c) {
const LE &r = LE((S().get(), c ? B().get() : 0));
}
// CIR-LABEL: @_Z22test_combined_cleanupsb
-// CIR: %[[TMP_LE:.*]] = cir.alloca !rec_LE, !cir.ptr<!rec_LE>, ["ref.tmp0"]
-// CIR: %[[R:.*]] = cir.alloca !cir.ptr<!rec_LE>, !cir.ptr<!cir.ptr<!rec_LE>>, ["r", init, const]
-// CIR: %[[TMP_S:.*]] = cir.alloca !rec_S, !cir.ptr<!rec_S>, ["ref.tmp1"]
-// CIR: %[[TMP_B:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["ref.tmp2"]
-// CIR: %[[ACT_B:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["cleanup.cond"]
-// CIR: %[[SPILL:.*]] = cir.alloca !cir.ptr<!rec_LE>, !cir.ptr<!cir.ptr<!rec_LE>>, ["tmp.exprcleanup"]
+// CIR: %[[TMP_LE:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_LE>
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_LE>>
+// CIR: %[[TMP_S:.*]] = cir.alloca "ref.tmp1" {{.*}} : !cir.ptr<!rec_S>
+// CIR: %[[TMP_B:.*]] = cir.alloca "ref.tmp2" {{.*}} : !cir.ptr<!rec_B>
+// CIR: %[[ACT_B:.*]] = cir.alloca "cleanup.cond" {{.*}} : !cir.ptr<!cir.bool>
+// CIR: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.ptr<!rec_LE>>
// CIR: cir.cleanup.scope {
// CIR: cir.call @_ZN1SC1Ev(%[[TMP_S]])
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/cleanup-derived-to-base-ref.cpp b/clang/test/CIR/CodeGen/cleanup-derived-to-base-ref.cpp
index 8197f849a3d2e..b5f3f2ff2aeca 100644
--- a/clang/test/CIR/CodeGen/cleanup-derived-to-base-ref.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-derived-to-base-ref.cpp
@@ -15,9 +15,9 @@ void bind_base_ref_to_derived_temp() {
}
// CIR-LABEL: cir.func {{.*}}@_Z29bind_base_ref_to_derived_tempv
-// CIR: %[[REF_TMP:.*]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["ref.tmp0"]
-// CIR: %[[R:.*]] = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["r", init, const]
-// CIR: %[[SPILL:.*]] = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["tmp.exprcleanup"]
+// CIR: %[[REF_TMP:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_Derived>
+// CIR: %[[R:.*]] = cir.alloca "r" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Base>>
+// CIR: %[[SPILL:.*]] = cir.alloca "tmp.exprcleanup" {{.*}} : !cir.ptr<!cir.ptr<!rec_Base>>
// CIR: cir.call @_Z12make_derivedv()
// CIR: cir.cleanup.scope {
// CIR: %[[BASE:.*]] = cir.base_class_addr %[[REF_TMP]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
diff --git a/clang/test/CIR/CodeGen/complex-atomic-cast.c b/clang/test/CIR/CodeGen/complex-atomic-cast.c
index 112e369d7e2ff..dbc5a4dbc9e00 100644
--- a/clang/test/CIR/CodeGen/complex-atomic-cast.c
+++ b/clang/test/CIR/CodeGen/complex-atomic-cast.c
@@ -36,9 +36,9 @@ void atomic_complex_to_complex() {
_Complex int b = a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["b", init]
-// CIR: %[[ATOMIC_TMP_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["atomic-temp"]
+// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[ATOMIC_TMP_ADDR:.*]] = cir.alloca "atomic-temp" {{.*}} : !cir.ptr<!cir.complex<!s32i>>
// CIR: %[[A_U64I:.*]] = cir.cast bitcast %[[A_ADDR]] : !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!u64i>
// CIR: %[[TMP_A:.*]] = cir.load {{.*}} atomic(seq_cst) %[[A_U64I]] : !cir.ptr<!u64i>, !u64i
// CIR: %[[ATOMIC_TMP_U64I:.*]] = cir.cast bitcast %[[ATOMIC_TMP_ADDR]] : !cir.ptr<!cir.complex<!s32i>> -> !cir.ptr<!u64i>
diff --git a/clang/test/CIR/CodeGen/coro-exceptions.cpp b/clang/test/CIR/CodeGen/coro-exceptions.cpp
index e72cd850bf4eb..7ccca4d2b7006 100644
--- a/clang/test/CIR/CodeGen/coro-exceptions.cpp
+++ b/clang/test/CIR/CodeGen/coro-exceptions.cpp
@@ -89,7 +89,7 @@ TaskThrowingInit throwing_init_suspend() {
}
// CIR-LABEL: cir.func{{.*}} @_Z21throwing_init_suspendv
-// CIR: %[[RESUME_FLAG:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["resume.eh"] {alignment = 1 : i64}
+// CIR: %[[RESUME_FLAG:.*]] = cir.alloca "resume.eh" align(1) : !cir.ptr<!cir.bool>
// CIR: }, resume : {
// CIR: %[[FALSE:.*]] = cir.const #false
// CIR: cir.store %[[FALSE]], %[[RESUME_FLAG]] : !cir.bool, !cir.ptr<!cir.bool>
diff --git a/clang/test/CIR/CodeGen/switch-cleanup.cpp b/clang/test/CIR/CodeGen/switch-cleanup.cpp
index 01e5385585e84..0caed937a3154 100644
--- a/clang/test/CIR/CodeGen/switch-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/switch-cleanup.cpp
@@ -20,7 +20,7 @@ void simple_stmt_body(int x) {
// CIR-LABEL: cir.func{{.*}} @_Z16simple_stmt_bodyi
// CIR: cir.scope {
-// CIR: cir.alloca !rec_BitVector, !cir.ptr<!rec_BitVector>, ["bv"]
+// CIR: cir.alloca "bv" {{.*}} : !cir.ptr<!rec_BitVector>
// CIR: cir.switch(%{{.*}} : !s32i) {
// CIR: cir.cleanup.scope {
// CIR: cir.yield
@@ -53,7 +53,7 @@ void compound_stmt_body(int x) {
// CIR-LABEL: cir.func{{.*}} @_Z18compound_stmt_bodyi
// CIR: cir.scope {
-// CIR: cir.alloca !rec_BitVector, !cir.ptr<!rec_BitVector>, ["bv"]
+// CIR: cir.alloca "bv" {{.*}} : !cir.ptr<!rec_BitVector>
// CIR: cir.switch(%{{.*}} : !s32i) {
// CIR: cir.cleanup.scope {
// CIR: cir.yield
@@ -88,7 +88,7 @@ void cleanup_in_case(int x) {
// CIR-LABEL: cir.func{{.*}} @_Z15cleanup_in_casei
// CIR: cir.scope {
-// CIR: cir.alloca !rec_BitVector, !cir.ptr<!rec_BitVector>, ["bv"]
+// CIR: cir.alloca "bv" {{.*}} : !cir.ptr<!rec_BitVector>
// CIR: cir.switch(%{{.*}} : !s32i) {
// CIR: cir.case(default, []) {
// CIR: cir.break
@@ -149,7 +149,7 @@ void cleanup_in_while_in_switch(int x) {
// CIR: cir.condition
// CIR: } do {
// CIR: cir.scope {
-// CIR: cir.alloca !rec_BitVector, !cir.ptr<!rec_BitVector>, ["bv"]
+// CIR: cir.alloca "bv" {{.*}} : !cir.ptr<!rec_BitVector>
// CIR: cir.case(default, []) {
// CIR: cir.break
// CIR: }
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index cf288b68b3919..30acf03706e9d 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -54,13 +54,13 @@ void vla_bool_size(_Bool len) {
}
// CIR-LABEL: cir.func {{.*}}@vla_bool_size
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["len", init]
-// CIR: %[[SAVED_STACK:.*]] = cir.alloca !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>, ["saved_stack"]
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!cir.bool>
+// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: %[[LEN:.*]] = cir.load{{.*}} %[[LEN_ADDR]]
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast bool_to_int %[[LEN]] : !cir.bool -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave
// CIR: cir.store{{.*}} %[[STACK_PTR]], %[[SAVED_STACK]]
-// CIR: %[[ARR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, %[[LEN_SIZE_T]] : !u64i, ["arr"]
+// CIR: %[[ARR:.*]] = cir.alloca "arr" {{.*}} size(%[[LEN_SIZE_T]]) : !cir.ptr<!s32i>
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load{{.*}} %[[SAVED_STACK]]
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
//
diff --git a/clang/test/CIR/CodeGenOpenCL/address-space-local-var.clcpp b/clang/test/CIR/CodeGenOpenCL/address-space-local-var.clcpp
index 68d54672d67dd..bfce737207e87 100644
--- a/clang/test/CIR/CodeGenOpenCL/address-space-local-var.clcpp
+++ b/clang/test/CIR/CodeGenOpenCL/address-space-local-var.clcpp
@@ -9,9 +9,9 @@
// where auto variables have the opencl_private address space.
// CIR: cir.func {{.*}} @k(%arg0: !cir.ptr<!s32i>
-// CIR: %[[GP:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["gp", init]
-// CIR: %[[GR_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["gr", init, const]
-// CIR: %[[R_ALLOCA:.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["r", init, const]
+// CIR: %[[GP:.*]] = cir.alloca "gp" {{.*}} init : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[GR_ALLOCA:.*]] = cir.alloca "gr" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[R_ALLOCA:.*]] = cir.alloca "r" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[R:.*]] = cir.cast address_space %[[R_ALLOCA]] : !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[GR:.*]] = cir.cast address_space %[[GR_ALLOCA]] : !cir.ptr<!cir.ptr<!s32i>> -> !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.store %arg0, %[[GP]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
diff --git a/clang/test/CIR/CodeGenOpenCL/as_type.cl b/clang/test/CIR/CodeGenOpenCL/as_type.cl
index da59e6451c912..303ebebc1f258 100644
--- a/clang/test/CIR/CodeGenOpenCL/as_type.cl
+++ b/clang/test/CIR/CodeGenOpenCL/as_type.cl
@@ -69,8 +69,8 @@ char3 vec4_to_vec_3(char4 x) {
}
// CIR: cir.func {{.*}} @vec4_to_vec_3
-// CIR: %[[X_ADDR:.*]] = cir.alloca !cir.vector<4 x !s8i>, !cir.ptr<!cir.vector<4 x !s8i>>, ["x", init]
-// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.vector<3 x !s8i>, !cir.ptr<!cir.vector<3 x !s8i>>, ["__retval"]
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.vector<4 x !s8i>>
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<3 x !s8i>>
// CIR: cir.store %{{.*}}, %[[X_ADDR]] : !cir.vector<4 x !s8i>, !cir.ptr<!cir.vector<4 x !s8i>>
// CIR: %[[TMP_X:.*]] = cir.load {{.*}} %[[X_ADDR]] : !cir.ptr<!cir.vector<4 x !s8i>>, !cir.vector<4 x !s8i>
// CIR: %[[POISON:.*]] = cir.const #cir.poison : !cir.vector<4 x !s8i>
diff --git a/clang/test/CIR/IR/lifetime.cir b/clang/test/CIR/IR/lifetime.cir
index 5b310d93679d1..4f482192caece 100644
--- a/clang/test/CIR/IR/lifetime.cir
+++ b/clang/test/CIR/IR/lifetime.cir
@@ -5,7 +5,7 @@
!s32i = !cir.int<s, 32>
cir.func @lifetime_start_end() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) : !cir.ptr<!s32i>
// CHECK: cir.lifetime.start %0 : !cir.ptr<!s32i>
cir.lifetime.start %0 : !cir.ptr<!s32i>
// CHECK: cir.lifetime.end %0 : !cir.ptr<!s32i>
diff --git a/clang/test/CIR/Lowering/lifetime.cir b/clang/test/CIR/Lowering/lifetime.cir
index 70db17eae76bf..09a0f4b390cc8 100644
--- a/clang/test/CIR/Lowering/lifetime.cir
+++ b/clang/test/CIR/Lowering/lifetime.cir
@@ -3,7 +3,7 @@
!s32i = !cir.int<s, 32>
cir.func @lifetime_markers() {
- %0 = cir.alloca !s32i, !cir.ptr<!s32i>, ["x"] {alignment = 4 : i64}
+ %0 = cir.alloca "x" align(4) : !cir.ptr<!s32i>
// CHECK: call void @llvm.lifetime.start.p0(ptr %[[X:.*]])
cir.lifetime.start %0 : !cir.ptr<!s32i>
// CHECK: call void @llvm.lifetime.end.p0(ptr %[[X]])
diff --git a/clang/test/CIR/Transforms/abi-lowering/coerce-int-to-record.cir b/clang/test/CIR/Transforms/abi-lowering/coerce-int-to-record.cir
index 94e6beb89c4e4..2f9f05386d921 100644
--- a/clang/test/CIR/Transforms/abi-lowering/coerce-int-to-record.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/coerce-int-to-record.cir
@@ -29,7 +29,7 @@ module attributes {
// Record return operand coerced to !s64i through an entry-block memory slot.
// CHECK: cir.func{{.*}} @returns_pair() -> !s64i
- // CHECK: %[[SLOT:.*]] = cir.alloca !rec_Pair, !cir.ptr<!rec_Pair>, ["coerce"]
+ // CHECK: %[[SLOT:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!rec_Pair>
// CHECK: %[[VAL:.*]] = cir.const #cir.zero : !rec_Pair
// CHECK: cir.store %[[VAL]], %[[SLOT]] : !rec_Pair, !cir.ptr<!rec_Pair>
// CHECK: %[[CAST:.*]] = cir.cast bitcast %[[SLOT]] : !cir.ptr<!rec_Pair> -> !cir.ptr<!s64i>
@@ -39,7 +39,7 @@ module attributes {
cir.func @caller() -> !s32i
attributes { test_classify = #caller_ret_i32 } {
%0 = cir.call @returns_pair() : () -> !rec_Pair
- %1 = cir.alloca !rec_Pair, !cir.ptr<!rec_Pair>, ["r"] {alignment = 4 : i64}
+ %1 = cir.alloca "r" align(4) : !cir.ptr<!rec_Pair>
cir.store %0, %1 : !rec_Pair, !cir.ptr<!rec_Pair>
%2 = cir.get_member %1[0] {name = "first"} : !cir.ptr<!rec_Pair> -> !cir.ptr<!s32i>
%3 = cir.load %2 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/abi-lowering/coerce-record-return-larger.cir b/clang/test/CIR/Transforms/abi-lowering/coerce-record-return-larger.cir
index e5a3986c0c4e1..c13c52182bfff 100644
--- a/clang/test/CIR/Transforms/abi-lowering/coerce-record-return-larger.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/coerce-record-return-larger.cir
@@ -33,7 +33,7 @@ module attributes {
// and the store goes through a source-typed view of it; loading !rec_TwoI64
// out of a !rec_Vec3-sized slot would read past the allocation.
// CHECK: cir.func{{.*}} @returns_vec3() -> !rec_TwoI64
- // CHECK: %[[SLOT:.*]] = cir.alloca !rec_TwoI64, !cir.ptr<!rec_TwoI64>, ["coerce"]
+ // CHECK: %[[SLOT:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!rec_TwoI64>
// CHECK: %[[VAL:.*]] = cir.const #cir.zero : !rec_Vec3
// CHECK: %[[CAST:.*]] = cir.cast bitcast %[[SLOT]] : !cir.ptr<!rec_TwoI64> -> !cir.ptr<!rec_Vec3>
// CHECK: cir.store %[[VAL]], %[[CAST]] : !rec_Vec3, !cir.ptr<!rec_Vec3>
@@ -43,7 +43,7 @@ module attributes {
cir.func @caller() -> !s32i
attributes { test_classify = #caller_ret_i32 } {
%0 = cir.call @returns_vec3() : () -> !rec_Vec3
- %1 = cir.alloca !rec_Vec3, !cir.ptr<!rec_Vec3>, ["r"] {alignment = 4 : i64}
+ %1 = cir.alloca "r" align(4) : !cir.ptr<!rec_Vec3>
cir.store %0, %1 : !rec_Vec3, !cir.ptr<!rec_Vec3>
%2 = cir.get_member %1[0] {name = "first"} : !cir.ptr<!rec_Vec3> -> !cir.ptr<!s32i>
%3 = cir.load %2 : !cir.ptr<!s32i>, !s32i
diff --git a/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-int.cir b/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-int.cir
index fd9cacde30247..0597d5ce5dd3a 100644
--- a/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-int.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-int.cir
@@ -23,23 +23,23 @@ module attributes {
cir.func @takes_pair(%arg0: !rec_Pair)
attributes { test_classify = #coerce_pair_to_i64 } {
- %0 = cir.alloca !rec_Pair, !cir.ptr<!rec_Pair>, ["p"] {alignment = 4 : i64}
+ %0 = cir.alloca "p" align(4) : !cir.ptr<!rec_Pair>
cir.store %arg0, %0 : !rec_Pair, !cir.ptr<!rec_Pair>
cir.return
}
// Entry-block memory roundtrip recovers !rec_Pair from the !s64i argument.
// CHECK: cir.func{{.*}} @takes_pair(%[[ARG:.*]]: !s64i)
- // CHECK: %[[SLOT:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["coerce"]
+ // CHECK: %[[SLOT:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!s64i>
// CHECK: cir.store %[[ARG]], %[[SLOT]] : !s64i, !cir.ptr<!s64i>
// CHECK: %[[CAST:.*]] = cir.cast bitcast %[[SLOT]] : !cir.ptr<!s64i> -> !cir.ptr<!rec_Pair>
// CHECK: %[[REC:.*]] = cir.load %[[CAST]] : !cir.ptr<!rec_Pair>, !rec_Pair
- // CHECK: %[[P:.*]] = cir.alloca !rec_Pair, !cir.ptr<!rec_Pair>, ["p"]
+ // CHECK: %[[P:.*]] = cir.alloca "p" {{.*}} : !cir.ptr<!rec_Pair>
// CHECK: cir.store %[[REC]], %[[P]] : !rec_Pair, !cir.ptr<!rec_Pair>
cir.func @caller()
attributes { test_classify = #caller_no_args } {
- %0 = cir.alloca !rec_Pair, !cir.ptr<!rec_Pair>, ["p"] {alignment = 4 : i64}
+ %0 = cir.alloca "p" align(4) : !cir.ptr<!rec_Pair>
%1 = cir.load %0 : !cir.ptr<!rec_Pair>, !rec_Pair
cir.call @takes_pair(%1) : (!rec_Pair) -> ()
cir.return
diff --git a/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-record-via-memory.cir b/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-record-via-memory.cir
index 62ea2378623fd..fc972d74311bc 100644
--- a/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-record-via-memory.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/coerce-record-to-record-via-memory.cir
@@ -24,23 +24,23 @@ module attributes {
cir.func @takes_vec(%arg0: !rec_Vec4)
attributes { test_classify = #coerce_vec4_to_twoi64 } {
- %0 = cir.alloca !rec_Vec4, !cir.ptr<!rec_Vec4>, ["v"] {alignment = 4 : i64}
+ %0 = cir.alloca "v" align(4) : !cir.ptr<!rec_Vec4>
cir.store %arg0, %0 : !rec_Vec4, !cir.ptr<!rec_Vec4>
cir.return
}
// 16-byte struct coerced to a two-eightbyte record through memory.
// CHECK: cir.func{{.*}} @takes_vec(%[[ARG:.*]]: !rec_TwoI64)
- // CHECK: %[[SLOT:.*]] = cir.alloca !rec_TwoI64, !cir.ptr<!rec_TwoI64>, ["coerce"]
+ // CHECK: %[[SLOT:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!rec_TwoI64>
// CHECK: cir.store %[[ARG]], %[[SLOT]] : !rec_TwoI64, !cir.ptr<!rec_TwoI64>
// CHECK: %[[CAST:.*]] = cir.cast bitcast %[[SLOT]] : !cir.ptr<!rec_TwoI64> -> !cir.ptr<!rec_Vec4>
// CHECK: %[[REC:.*]] = cir.load %[[CAST]] : !cir.ptr<!rec_Vec4>, !rec_Vec4
- // CHECK: %[[V:.*]] = cir.alloca !rec_Vec4, !cir.ptr<!rec_Vec4>, ["v"]
+ // CHECK: %[[V:.*]] = cir.alloca "v" {{.*}} : !cir.ptr<!rec_Vec4>
// CHECK: cir.store %[[REC]], %[[V]] : !rec_Vec4, !cir.ptr<!rec_Vec4>
cir.func @caller()
attributes { test_classify = #caller_no_args } {
- %0 = cir.alloca !rec_Vec4, !cir.ptr<!rec_Vec4>, ["v"] {alignment = 4 : i64}
+ %0 = cir.alloca "v" align(4) : !cir.ptr<!rec_Vec4>
%1 = cir.load %0 : !cir.ptr<!rec_Vec4>, !rec_Vec4
cir.call @takes_vec(%1) : (!rec_Vec4) -> ()
cir.return
diff --git a/clang/test/CIR/Transforms/abi-lowering/coerce-vector-to-complex.cir b/clang/test/CIR/Transforms/abi-lowering/coerce-vector-to-complex.cir
index f1ccceb8541c8..a1eebacd7af8c 100644
--- a/clang/test/CIR/Transforms/abi-lowering/coerce-vector-to-complex.cir
+++ b/clang/test/CIR/Transforms/abi-lowering/coerce-vector-to-complex.cir
@@ -19,7 +19,7 @@ module attributes {
// Entry-block memory roundtrip recovers the complex from the vector arg.
// CHECK: cir.func{{.*}} @takes_complex(%[[ARG:.*]]: !cir.vector<2 x !cir.float>)
- // CHECK: %[[SLOT:.*]] = cir.alloca !cir.vector<2 x !cir.float>, !cir.ptr<!cir.vector<2 x !cir.float>>, ["coerce"]
+ // CHECK: %[[SLOT:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.float>>
// CHECK: cir.store %[[ARG]], %[[SLOT]] : !cir.vector<2 x !cir.float>, !cir.ptr<!cir.vector<2 x !cir.float>>
// CHECK: %[[CAST:.*]] = cir.cast bitcast %[[SLOT]] : !cir.ptr<!cir.vector<2 x !cir.float>> -> !cir.ptr<!cir.complex<!cir.float>>
// CHECK: %{{.*}} = cir.load %[[CAST]] : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
@@ -33,7 +33,7 @@ module attributes {
// Call site coerces the complex value to the vector type through memory.
// CHECK: cir.func{{.*}} @caller(%[[ARG:.*]]: !cir.vector<2 x !cir.float>)
// CHECK: %[[COMPLEX:.*]] = cir.load %{{.*}} : !cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
- // CHECK: %[[CSLOT:.*]] = cir.alloca !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["coerce"]
+ // CHECK: %[[CSLOT:.*]] = cir.alloca "coerce" {{.*}} : !cir.ptr<!cir.complex<!cir.float>>
// CHECK: cir.store %[[COMPLEX]], %[[CSLOT]] : !cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// CHECK: %[[CCAST:.*]] = cir.cast bitcast %[[CSLOT]] : !cir.ptr<!cir.complex<!cir.float>> -> !cir.ptr<!cir.vector<2 x !cir.float>>
// CHECK: %[[COERCED:.*]] = cir.load %[[CCAST]] : !cir.ptr<!cir.vector<2 x !cir.float>>, !cir.vector<2 x !cir.float>
More information about the cfe-commits
mailing list