[clang] [CIR] Lay out allocas in the order classic codegen does (PR #231974)
Adam Smith via cfe-commits
cfe-commits at lists.llvm.org
Wed Oct 14 18:51:30 PDT 2026
https://github.com/adams381 updated https://github.com/llvm/llvm-project/pull/231974
>From 4a8fb9d158743f3c9aa9e7766c2539adbbebbf23 Mon Sep 17 00:00:00 2001
From: Adam Smith <adams at nvidia.com>
Date: Wed, 14 Oct 2026 08:56:09 -0700
Subject: [PATCH 1/4] [CIR] Lay out allocas in the order classic codegen does
At -O0 the order of a function's entry-block allocas is its stack frame
layout. CIR now creates the return value's alloca before the
parameters', and keeps hoisted block-scope allocas after the function's
own, matching classic codegen.
CIRGen creates `__retval` before the parameters, as classic's
StartFunction does, and the implicit `return 0` store for `main` moves
into emitFunctionProlog, where classic emits it. HoistAllocas places
each hoisted alloca after the allocas already at the start of the
destination block instead of in front of them.
Assisted-by: Cursor / claude-opus-5.5
---
clang/lib/CIR/CodeGen/CIRGenFunction.cpp | 55 ++---
clang/lib/CIR/CodeGen/CIRGenFunction.h | 5 +-
.../CIR/Dialect/Transforms/HoistAllocas.cpp | 10 +-
clang/test/CIR/CodeGen/alloca-order.cpp | 205 ++++++++++++++++++
clang/test/CIR/CodeGen/array-ctor.cpp | 2 +-
clang/test/CIR/CodeGen/array-dtor.cpp | 4 +-
clang/test/CIR/CodeGen/assign-operator.cpp | 3 +-
clang/test/CIR/CodeGen/base-to-derived.cpp | 3 +
clang/test/CIR/CodeGen/basic.c | 5 +-
clang/test/CIR/CodeGen/basic.cpp | 4 +-
clang/test/CIR/CodeGen/bitfields.c | 2 +-
clang/test/CIR/CodeGen/bitfields.cpp | 2 +-
clang/test/CIR/CodeGen/bitfields_be.c | 2 +-
clang/test/CIR/CodeGen/call.cpp | 2 +
clang/test/CIR/CodeGen/cast.cpp | 6 +-
clang/test/CIR/CodeGen/class.cpp | 2 +-
.../CIR/CodeGen/cleanup-conditional-eh.cpp | 2 +-
.../cleanup-conditional-with-wrapper-eh.cpp | 6 +-
.../cleanup-conditional-with-wrapper.cpp | 6 +-
.../test/CIR/CodeGen/cleanup-conditional.cpp | 4 +-
clang/test/CIR/CodeGen/complex.cpp | 24 +-
.../test/CIR/CodeGen/cxx-construct-lvalue.cpp | 9 +-
.../CIR/CodeGen/cxx-conversion-operators.cpp | 8 +-
.../CodeGen/delete-array-throwing-dtor.cpp | 3 +-
clang/test/CIR/CodeGen/derived-to-base.cpp | 3 +-
clang/test/CIR/CodeGen/destructors.cpp | 2 +-
clang/test/CIR/CodeGen/dtors.cpp | 6 +-
clang/test/CIR/CodeGen/ehspec.cpp | 19 ++
clang/test/CIR/CodeGen/fixed-point-arith.cpp | 102 ++++++---
clang/test/CIR/CodeGen/gnu-ptr-math.c | 32 +--
clang/test/CIR/CodeGen/if.cpp | 18 +-
clang/test/CIR/CodeGen/inline-asm.c | 32 +--
clang/test/CIR/CodeGen/inline-cxx-func.cpp | 4 +-
.../CIR/CodeGen/lambda-static-invoker.cpp | 16 +-
clang/test/CIR/CodeGen/lambda.cpp | 20 +-
clang/test/CIR/CodeGen/launder.cpp | 16 +-
clang/test/CIR/CodeGen/lifetime-marker.cpp | 1 +
.../test/CIR/CodeGen/long-double-inc-dec.cpp | 16 +-
.../CIR/CodeGen/loop-cond-var-cleanup.cpp | 16 +-
clang/test/CIR/CodeGen/loop.cpp | 2 +-
clang/test/CIR/CodeGen/pack-indexing.cpp | 10 +-
.../test/CIR/CodeGen/paren-list-agg-init.cpp | 11 +-
.../CodeGen/pointer-to-data-member-cast.cpp | 6 +-
.../CIR/CodeGen/pointer-to-data-member.cpp | 36 +--
.../CodeGen/pointer-to-member-func-cast.cpp | 4 +-
.../CodeGen/pointer-to-member-func-cmp.cpp | 8 +-
clang/test/CIR/CodeGen/requires-expr.cpp | 12 +-
clang/test/CIR/CodeGen/statement-exprs.c | 8 +-
clang/test/CIR/CodeGen/static-local.cpp | 4 +-
clang/test/CIR/CodeGen/stmt-expr.cpp | 4 +-
clang/test/CIR/CodeGen/struct.c | 8 +-
clang/test/CIR/CodeGen/switch.cpp | 6 +-
.../CIR/CodeGen/temporary-materialization.cpp | 10 +-
clang/test/CIR/CodeGen/ternary-throw.cpp | 6 +-
clang/test/CIR/CodeGen/ternary.cpp | 8 +-
clang/test/CIR/CodeGen/three-way-cmp.cpp | 12 +-
clang/test/CIR/CodeGen/throws.cpp | 4 +-
clang/test/CIR/CodeGen/try-catch.cpp | 6 +-
clang/test/CIR/CodeGen/unary.cpp | 160 +++++++-------
clang/test/CIR/CodeGen/var_arg.c | 3 +
clang/test/CIR/CodeGen/vla.c | 7 +-
.../X86/avx-shuffle-builtins.c | 8 +-
.../CIR/CodeGenBuiltins/builtin-fcmp-sse.c | 16 +-
.../test/CIR/CodeGenCoroutines/coro-task.cpp | 2 +-
clang/test/CIR/CodeGenOpenCL/as_type.cl | 8 +-
clang/test/CIR/CodeGenOpenCL/vector.cl | 8 +-
clang/test/CIR/Lowering/basic.cpp | 4 +-
clang/test/CIR/Transforms/hoist-allocas.cir | 51 +++++
68 files changed, 717 insertions(+), 392 deletions(-)
create mode 100644 clang/test/CIR/CodeGen/alloca-order.cpp
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
index 707df240b4bfe7..1b040de149e714 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
@@ -462,6 +462,14 @@ void CIRGenFunction::emitFunctionProlog(const FunctionArgList &args,
cgm.errorNYI(bodyBeginLoc, "naked function decl");
}
+ // If this is an implicit-return-zero function, initialize the return value.
+ if (fd && fd->hasImplicitReturnZero()) {
+ mlir::Type retTy = convertType(fd->getReturnType().getUnqualifiedType());
+ mlir::Location loc = getLoc(bodyBeginLoc);
+ mlir::Value zero = builder.getNullValue(retTy, loc);
+ builder.CIRBaseBuilderTy::createStore(loc, zero, returnValue.getPointer());
+ }
+
// Declare all the function arguments in the symbol table.
for (const auto nameValue : llvm::zip(args, entryBB->getArguments())) {
const VarDecl *paramVar = std::get<0>(nameValue);
@@ -548,6 +556,22 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
mlir::Block *entryBB = &fn.getBlocks().front();
builder.setInsertionPointToStart(entryBB);
+ // When the current function is not void, create an address to store the
+ // result value.
+ if (!returnType->isVoidType()) {
+ // Determine the function body end location.
+ // If fd is null or has no body, use loc as fallback.
+ SourceLocation bodyEndLoc = loc;
+ if (fd) {
+ if (Stmt *body = fd->getBody())
+ bodyEndLoc = body->getEndLoc();
+ else
+ bodyEndLoc = fd->getLocation();
+ }
+ emitAndUpdateRetAlloca(returnType, getLoc(bodyEndLoc),
+ getContext().getTypeAlignInChars(returnType));
+ }
+
// Wrap the rest of the function in a filter try when this declaration has
// a dynamic exception specification. Parameter cleanups are pushed after
// this so they nest inside the specification, matching classic codegen.
@@ -566,37 +590,6 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
emitFunctionProlog(args, entryBB, fd, bodyBeginLoc);
- // When the current function is not void, create an address to store the
- // result value.
- if (!returnType->isVoidType()) {
- // Determine the function body end location.
- // If fd is null or has no body, use loc as fallback.
- SourceLocation bodyEndLoc = loc;
- if (fd) {
- if (Stmt *body = fd->getBody())
- bodyEndLoc = body->getEndLoc();
- else
- bodyEndLoc = fd->getLocation();
- }
- emitAndUpdateRetAlloca(returnType, getLoc(bodyEndLoc),
- getContext().getTypeAlignInChars(returnType));
-
- // If this is an implicit-return-zero function, initialize the return
- // value. This mirrors the implicit-return-zero handling in classic
- // codegen's EmitFunctionProlog (CGCall.cpp). It is done here, after
- // emitAndUpdateRetAlloca, because in CIR the return slot is created
- // after the prolog (the opposite of classic codegen, where ReturnValue
- // is set up before EmitFunctionProlog runs).
- // TODO(cir): Align prolog handling with classic codegen.
- if (fd && fd->hasImplicitReturnZero()) {
- mlir::Type cirRetTy = convertType(returnType.getUnqualifiedType());
- mlir::Location bodyBeginMLIRLoc = getLoc(bodyBeginLoc);
- mlir::Value zero = builder.getNullValue(cirRetTy, bodyBeginMLIRLoc);
- builder.CIRBaseBuilderTy::createStore(bodyBeginMLIRLoc, zero,
- returnValue.getPointer());
- }
- }
-
if (const auto *md = dyn_cast_if_present<CXXMethodDecl>(d);
md && !md->isStatic()) {
bool isInLambda =
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h
index 8937e237a64141..21d544dd633cfd 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.h
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h
@@ -1193,8 +1193,9 @@ class CIRGenFunction : public CIRGenTypeCache {
clang::QualType buildFunctionArgList(clang::GlobalDecl gd,
FunctionArgList &args);
- /// Emit the function prologue: declare function arguments in the symbol
- /// table.
+ /// Emit the function prologue: initialize the return value of an
+ /// implicit-return-zero function and declare function arguments in the
+ /// symbol table.
void emitFunctionProlog(const FunctionArgList &args, mlir::Block *entryBB,
const FunctionDecl *fd, SourceLocation bodyBeginLoc);
diff --git a/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp b/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp
index 1eb3e2524e124a..da3d7cc3aea53e 100644
--- a/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp
@@ -94,8 +94,14 @@ static void process(mlir::ModuleOp mod, cir::FuncOp func) {
if (alloca.getConstant())
alloca.setConstant(false);
- mlir::Operation *&insertPoint =
- insertPoints.try_emplace(destBlock, &*destBlock->begin()).first->second;
+ // Hoisted allocas go after the allocas already at the start of the
+ // destination block, so the return value and parameter allocas stay
+ // first, as in classic codegen.
+ mlir::Operation *&insertPoint = insertPoints[destBlock];
+ if (!insertPoint)
+ insertPoint = &*llvm::find_if(*destBlock, [](mlir::Operation &blockOp) {
+ return !mlir::isa<cir::AllocaOp>(blockOp);
+ });
alloca->moveBefore(insertPoint);
});
}
diff --git a/clang/test/CIR/CodeGen/alloca-order.cpp b/clang/test/CIR/CodeGen/alloca-order.cpp
new file mode 100644
index 00000000000000..ec733a7dbb1235
--- /dev/null
+++ b/clang/test/CIR/CodeGen/alloca-order.cpp
@@ -0,0 +1,205 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t-cir.ll
+// RUN: FileCheck --check-prefixes=LLVM,LLVMCIR --input-file=%t-cir.ll %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll
+// RUN: FileCheck --check-prefixes=LLVM,OGCG --input-file=%t.ll %s
+
+void use(int *);
+
+int main(int argc, char **argv) {
+ {
+ int x = 1;
+ use(&x);
+ }
+ return 0;
+}
+
+// CIR: cir.func {{.*}} @main(
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[ARGC:.*]] = cir.alloca "argc" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[ARGV:.*]] = cir.alloca "argv" align(8) init : !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
+// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR-NEXT: cir.store %[[ZERO]], %[[RETVAL]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[ARGC]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[ARGV]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
+// CIR-NEXT: cir.scope {
+// CIR-NEXT: %[[X:.*]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
+
+// LLVM: define dso_local noundef i32 @main(i32 noundef %{{.+}}, ptr noundef %{{.+}})
+// LLVM: %[[RETVAL:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[ARGC:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[ARGV:.*]] = alloca ptr, align 8
+// LLVM-NEXT: %[[X:.*]] = alloca i32, align 4
+// LLVM-NEXT: store i32 0, ptr %[[RETVAL]], align 4
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[ARGC]], align 4
+// LLVM-NEXT: store ptr %{{.+}}, ptr %[[ARGV]], align 8
+// LLVM: store i32 1, ptr %[[X]], align 4
+
+int pick(int a, int b) {
+ if (a)
+ return a;
+ {
+ int t = b;
+ use(&t);
+ }
+ return b;
+}
+
+// CIR: cir.func {{.*}} @_Z4pickii(
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[A]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[B]] : !s32i, !cir.ptr<!s32i>
+
+// LLVM: define dso_local noundef i32 @_Z4pickii(i32 noundef %{{.+}}, i32 noundef %{{.+}})
+// LLVM: %[[RETVAL:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[T:.*]] = alloca i32, align 4
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[A]], align 4
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[B]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[T]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[RETVAL]], align 4
+
+int late(int a) {
+ int x = a;
+ use(&x);
+ {
+ int y = x;
+ use(&y);
+ }
+ int z = a;
+ use(&z);
+ if (z)
+ return x;
+ return z;
+}
+
+// CIR: cir.func {{.*}} @_Z4latei(
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[X:.*]] = cir.alloca "x" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[Z:.*]] = cir.alloca "z" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[A]] : !s32i, !cir.ptr<!s32i>
+// CIR: cir.scope {
+// CIR: %[[Y:.*]] = cir.alloca "y" align(4) init : !cir.ptr<!s32i>
+
+// LLVM: define dso_local noundef i32 @_Z4latei(i32 noundef %{{.+}})
+// LLVM: %[[RETVAL:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[X:.*]] = alloca i32, align 4
+// CIR places z, a function-scope local, ahead of the nested block's y.
+// LLVMCIR-NEXT: %[[Z:.*]] = alloca i32, align 4
+// LLVMCIR-NEXT: %[[Y:.*]] = alloca i32, align 4
+// OGCG-NEXT: %[[Y:.*]] = alloca i32, align 4
+// OGCG-NEXT: %[[Z:.*]] = alloca i32, align 4
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[A]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[X]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[Y]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[Z]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[RETVAL]], align 4
+
+struct S {
+ int m;
+ void set(int k);
+ int pick(int k);
+};
+
+void S::set(int k) {
+ {
+ int y = k;
+ use(&y);
+ }
+ m = k;
+}
+
+// CIR: cir.func {{.*}} @_ZN1S3setEi(
+// CIR-NEXT: %[[THIS:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
+// CIR-NEXT: %[[K:.*]] = cir.alloca "k" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[THIS]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
+// CIR-NEXT: cir.store %{{.+}}, %[[K]] : !s32i, !cir.ptr<!s32i>
+
+// LLVM: define dso_local void @_ZN1S3setEi(ptr noundef nonnull align 4 dereferenceable(4) %{{.+}}, i32 noundef %{{.+}})
+// LLVM: %[[THIS:.*]] = alloca ptr, align 8
+// LLVM-NEXT: %[[K:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[Y:.*]] = alloca i32, align 4
+// LLVM-NEXT: store ptr %{{.+}}, ptr %[[THIS]], align 8
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[K]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[Y]], align 4
+
+int S::pick(int k) {
+ if (k)
+ return m;
+ {
+ int w = k;
+ use(&w);
+ }
+ return k;
+}
+
+// CIR: cir.func {{.*}} @_ZN1S4pickEi(
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[THIS:.*]] = cir.alloca "this" align(8) init : !cir.ptr<!cir.ptr<!rec_S>>
+// CIR-NEXT: %[[K:.*]] = cir.alloca "k" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[THIS]] : !cir.ptr<!rec_S>, !cir.ptr<!cir.ptr<!rec_S>>
+// CIR-NEXT: cir.store %{{.+}}, %[[K]] : !s32i, !cir.ptr<!s32i>
+
+// LLVM: define dso_local noundef i32 @_ZN1S4pickEi(ptr noundef nonnull align 4 dereferenceable(4) %{{.+}}, i32 noundef %{{.+}})
+// LLVM: %[[RETVAL:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[THIS:.*]] = alloca ptr, align 8
+// LLVM-NEXT: %[[K:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[W:.*]] = alloca i32, align 4
+// LLVM-NEXT: store ptr %{{.+}}, ptr %[[THIS]], align 8
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[K]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[W]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[RETVAL]], align 4
+
+struct Big {
+ int a[8];
+};
+
+Big makeBig(int v) {
+ Big b;
+ {
+ int z = v;
+ use(&z);
+ }
+ b.a[0] = v;
+ return b;
+}
+
+// CIR: cir.func {{.*}} @_Z7makeBigi(
+// CIR-NEXT: %[[V:.*]] = cir.alloca "v" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: cir.store %{{.+}}, %[[V]] : !s32i, !cir.ptr<!s32i>
+
+// LLVM: define dso_local void @_Z7makeBigi(ptr dead_on_unwind noalias writable sret(%struct.Big) align 4 %{{.+}}, i32 noundef %{{.+}})
+// LLVM: %[[V:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[Z:.*]] = alloca i32, align 4
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[V]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[Z]], align 4
+
+Big makeBig2(int v) {
+ Big b;
+ {
+ int z = v;
+ use(&z);
+ }
+ if (v)
+ return Big{};
+ b.a[0] = v;
+ return b;
+}
+
+// CIR: cir.func {{.*}} @_Z8makeBig2i(
+// CIR-NEXT: %[[V:.*]] = cir.alloca "v" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) : !cir.ptr<!rec_Big>
+// CIR-NEXT: cir.store %{{.+}}, %[[V]] : !s32i, !cir.ptr<!s32i>
+
+// LLVM: define dso_local void @_Z8makeBig2i(ptr dead_on_unwind noalias writable sret(%struct.Big) align 4 %{{.+}}, i32 noundef %{{.+}})
+// LLVM: %[[V:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[B:.*]] = alloca %struct.Big, align 4
+// LLVM-NEXT: %[[Z:.*]] = alloca i32, align 4
+// LLVM-NEXT: store i32 %{{.+}}, ptr %[[V]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[Z]], align 4
diff --git a/clang/test/CIR/CodeGen/array-ctor.cpp b/clang/test/CIR/CodeGen/array-ctor.cpp
index 16eb8a57ee6d8e..0c2e9652bdccb6 100644
--- a/clang/test/CIR/CodeGen/array-ctor.cpp
+++ b/clang/test/CIR/CodeGen/array-ctor.cpp
@@ -319,8 +319,8 @@ void Temp2InArray() {
// LLVM-LABEL: define {{.*}}void @_Z12Temp2InArrayv()
-// LLVM: %[[DTOR_ITR:.*]] = alloca ptr
// LLVM: %[[TMP:.*]] = alloca %struct.Temp2
+// LLVM: %[[DTOR_ITR:.*]] = alloca ptr
// LLVM: %[[ITER:.*]] = alloca ptr
// LLVM: br label %[[DO_BR:.*]]
// LLVM: [[DO_BR]]:
diff --git a/clang/test/CIR/CodeGen/array-dtor.cpp b/clang/test/CIR/CodeGen/array-dtor.cpp
index 11e685c92514fc..bd57bbcc0f1a68 100644
--- a/clang/test/CIR/CodeGen/array-dtor.cpp
+++ b/clang/test/CIR/CodeGen/array-dtor.cpp
@@ -44,8 +44,8 @@ void test_cleanup_array() {
// CIR: cir.return
// LLVM: define{{.*}} void @_Z18test_cleanup_arrayv()
-// LLVM: %[[ITER:.*]] = alloca ptr
// LLVM: %[[ARRAY:.*]] = alloca [42 x %struct.S]
+// LLVM: %[[ITER:.*]] = alloca ptr
// LLVM: %[[START:.*]] = getelementptr %struct.S, ptr %[[ARRAY]], i32 0
// LLVM: %[[END:.*]] = getelementptr %struct.S, ptr %[[START]], i64 42
// LLVM: store ptr %[[END]], ptr %[[ITER]]
@@ -138,8 +138,8 @@ void multi_dimensional() {
// CIR: cir.return
// LLVM: define{{.*}} void @_Z17multi_dimensionalv()
-// LLVM: %[[ITER:.*]] = alloca ptr
// LLVM: %[[S:.*]] = alloca [3 x [5 x %struct.S]]
+// LLVM: %[[ITER:.*]] = alloca ptr
// LLVM: %[[START:.*]] = getelementptr %struct.S, ptr %[[S]], i32 0
// LLVM: %[[END:.*]] = getelementptr %struct.S, ptr %[[START]], i64 15
// LLVM: store ptr %[[END]], ptr %[[ITER]]
diff --git a/clang/test/CIR/CodeGen/assign-operator.cpp b/clang/test/CIR/CodeGen/assign-operator.cpp
index 5a874746ccb73d..991042e22d4d56 100644
--- a/clang/test/CIR/CodeGen/assign-operator.cpp
+++ b/clang/test/CIR/CodeGen/assign-operator.cpp
@@ -69,9 +69,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: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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]]
@@ -91,6 +91,7 @@ void copy_c(C &c1, C &c2) {
// CIR: cir.return %[[RET_VAL]]
// LLVM: define {{.*}} ptr @_ZN1CaSERKS_(ptr {{.*}} %[[THIS:.*]], ptr {{.*}} %[[ARG:.*]])
+// LLVM: %[[RETVAL_ADDR:.*]] = alloca ptr
// LLVM: %[[THIS_ADDR:.*]] = alloca ptr
// LLVM: %[[ARG_ADDR:.*]] = alloca ptr
// LLVM: store ptr %[[THIS]], ptr %[[THIS_ADDR]]
diff --git a/clang/test/CIR/CodeGen/base-to-derived.cpp b/clang/test/CIR/CodeGen/base-to-derived.cpp
index 430b096e88d9ee..90af757add335f 100644
--- a/clang/test/CIR/CodeGen/base-to-derived.cpp
+++ b/clang/test/CIR/CodeGen/base-to-derived.cpp
@@ -32,6 +32,7 @@ X *castAtoX(A *a) {
// Note: Because the offset is 0, a null check is not needed.
// LLVM: define {{.*}} ptr @_Z8castAtoXP1A(ptr {{.*}} %[[ARG0:.*]])
+// LLVM: %[[RETVAL:.*]] = alloca ptr
// LLVM: %[[A_ADDR:.*]] = alloca ptr
// LLVM: store ptr %[[ARG0]], ptr %[[A_ADDR]]
// LLVM: %[[X:.*]] = load ptr, ptr %[[A_ADDR]]
@@ -52,6 +53,7 @@ X *castBtoX(B *b) {
// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] [4] : !cir.ptr<!rec_B> -> !cir.ptr<!rec_X>
// LLVM: define {{.*}} ptr @_Z8castBtoXP1B(ptr {{.*}} %[[ARG0:.*]])
+// LLVM: %[[RETVAL:.*]] = alloca ptr, align 8
// LLVM: %[[B_ADDR:.*]] = alloca ptr, align 8
// LLVM: store ptr %[[ARG0]], ptr %[[B_ADDR]], align 8
// LLVM: %[[B:.*]] = load ptr, ptr %[[B_ADDR]], align 8
@@ -85,6 +87,7 @@ X &castBReftoXRef(B &b) {
// CIR: %[[X:.*]] = cir.derived_class_addr nonnull %[[B]] [4] : !cir.ptr<!rec_B> -> !cir.ptr<!rec_X>
// LLVM: define {{.*}} ptr @_Z14castBReftoXRefR1B(ptr {{.*}} %[[ARG0:.*]])
+// LLVM: %[[RETVAL:.*]] = alloca ptr
// LLVM: %[[B_ADDR:.*]] = alloca ptr
// LLVM: store ptr %[[ARG0]], ptr %[[B_ADDR]]
// LLVM: %[[B:.*]] = load ptr, ptr %[[B_ADDR]]
diff --git a/clang/test/CIR/CodeGen/basic.c b/clang/test/CIR/CodeGen/basic.c
index d841395f3fccde..ef246cb867208d 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 : !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: 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
@@ -45,8 +45,8 @@ int f1(int i) {
// CIR-NEXT: cir.return %[[R]] : !s32i
// LLVM: define{{.*}} i32 @f1(i32 noundef %[[IP:.*]])
-// LLVM-NEXT: %[[I_PTR:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[RV:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[I_PTR:.*]] = alloca i32, align 4
// LLVM-NEXT: store i32 %[[IP]], ptr %[[I_PTR]], align 4
// LLVM-NEXT: %[[I_IGNORED:.*]] = load i32, ptr %[[I_PTR]], align 4
// LLVM-NEXT: %[[I:.*]] = load i32, ptr %[[I_PTR]], align 4
@@ -206,6 +206,7 @@ int f7(int a, int b, int c) {
// CIR: %[[RETVAL:.*]] = cir.add nsw %[[A]], %[[B_PLUS_C]] : !s32i
// LLVM: define{{.*}} i32 @f7
+// LLVM: %[[RV:.*]] = alloca i32, align 4
// LLVM: %[[A_PTR:.*]] = alloca i32, align 4
// LLVM: %[[B_PTR:.*]] = alloca i32, align 4
// LLVM: %[[C_PTR:.*]] = alloca i32, align 4
diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp
index 6a31e07a382859..9ff798636c4bb4 100644
--- a/clang/test/CIR/CodeGen/basic.cpp
+++ b/clang/test/CIR/CodeGen/basic.cpp
@@ -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 : !cir.ptr<!s32i>
// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init : !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 : !cir.ptr<!s32i>
// CHECK: %[[RV:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CHECK: %[[ARG_ALLOCA:.*]] = cir.alloca "i" align(4) init const : !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>
diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c
index a0c46a63f4e01c..69766178c46132 100644
--- a/clang/test/CIR/CodeGen/bitfields.c
+++ b/clang/test/CIR/CodeGen/bitfields.c
@@ -101,8 +101,8 @@ int load_field(S* s) {
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
// LLVM: define dso_local i32 @load_field
-// LLVM: [[TMP0:%.*]] = alloca ptr, align 8
// LLVM: [[TMP1:%.*]] = alloca i32, align 4
+// LLVM: [[TMP0:%.*]] = alloca ptr, align 8
// LLVM: [[TMP2:%.*]] = load ptr, ptr [[TMP0]], align 8
// LLVM: [[TMP3:%.*]] = getelementptr inbounds nuw %struct.S, ptr [[TMP2]], i32 0, i32 0
// LLVM: [[TMP4:%.*]] = load i64, ptr [[TMP3]], align 4
diff --git a/clang/test/CIR/CodeGen/bitfields.cpp b/clang/test/CIR/CodeGen/bitfields.cpp
index 8bbc5aa5b8effb..4814c77460274a 100644
--- a/clang/test/CIR/CodeGen/bitfields.cpp
+++ b/clang/test/CIR/CodeGen/bitfields.cpp
@@ -52,8 +52,8 @@ int load_field(S* s) {
// CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u64i>) -> !s32i
// LLVM: define dso_local noundef i32 @_Z10load_fieldP1S
-// LLVM: [[TMP0:%.*]] = alloca ptr, align 8
// LLVM: [[TMP1:%.*]] = alloca i32, align 4
+// LLVM: [[TMP0:%.*]] = alloca ptr, align 8
// LLVM: [[TMP2:%.*]] = load ptr, ptr [[TMP0]], align 8
// LLVM: [[TMP3:%.*]] = getelementptr inbounds nuw %struct.S, ptr [[TMP2]], i32 0, i32 0
// LLVM: [[TMP4:%.*]] = load i64, ptr [[TMP3]], align 4
diff --git a/clang/test/CIR/CodeGen/bitfields_be.c b/clang/test/CIR/CodeGen/bitfields_be.c
index 86fade754ba98a..b7d4ce977904ec 100644
--- a/clang/test/CIR/CodeGen/bitfields_be.c
+++ b/clang/test/CIR/CodeGen/bitfields_be.c
@@ -28,8 +28,8 @@ int init(S* s) {
//CIR: [[TMP3:%.*]] = cir.get_bitfield align(4) (#bfi_c, [[TMP2]] : !cir.ptr<!u32i>) -> !s32i
//LLVM: define dso_local i32 @init
-//LLVM: [[TMP0:%.*]] = alloca ptr, align 8
//LLVM: [[TMP1:%.*]] = alloca i32, align 4
+//LLVM: [[TMP0:%.*]] = alloca ptr, align 8
//LLVM: [[TMP2:%.*]] = load ptr, ptr [[TMP0]], align 8
//LLVM: [[TMP3:%.*]] = getelementptr inbounds nuw %struct.S, ptr [[TMP2]], i32 0, i32 0
//LLVM: [[TMP4:%.*]] = load i32, ptr [[TMP3]], align 4
diff --git a/clang/test/CIR/CodeGen/call.cpp b/clang/test/CIR/CodeGen/call.cpp
index b7ffce1ebc0a68..915e5481730432 100644
--- a/clang/test/CIR/CodeGen/call.cpp
+++ b/clang/test/CIR/CodeGen/call.cpp
@@ -168,11 +168,13 @@ void use_TakesFunc() {
}
// CIR-LABEL: cir.func{{.*}} @_Z9TakesFuncIFivEEDcRKT_(
+// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!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})
// LLVM-LABEL: define{{.*}} @_Z9TakesFuncIFivEEDcRKT_(
+// LLVM-NEXT: %[[RETVAL:.*]] = alloca i32
// LLVM-NEXT: %[[FUNC_ALLOCA:.*]] = alloca ptr
// LLVM: %[[FUNC_LOAD:.*]] = load ptr, ptr %[[FUNC_ALLOCA]]
// LLVM-NEXT: %[[CALL:.*]] = call noundef i32 %[[FUNC_LOAD]]()
diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp
index fdac3056f60d92..5728015022d65f 100644
--- a/clang/test/CIR/CodeGen/cast.cpp
+++ b/clang/test/CIR/CodeGen/cast.cpp
@@ -8,13 +8,13 @@ unsigned char cxxstaticcast_0(unsigned int x) {
}
// CIR: cir.func{{.*}} @_Z15cxxstaticcast_0j
-// 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: %[[XPTR:[0-9]+]] = cir.alloca "x" align(4) init : !cir.ptr<!u32i>
// 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
// CIR: cir.store %[[CASTED]], %[[RV]] : !u8i, !cir.ptr<!u8i>
-// CIR: %[[R:[0-9]+]] = cir.load{{.*}} %1 : !cir.ptr<!u8i>, !u8i
+// CIR: %[[R:[0-9]+]] = cir.load{{.*}} %[[RV]] : !cir.ptr<!u8i>, !u8i
// CIR: cir.return %[[R]] : !u8i
// CIR: }
@@ -96,8 +96,8 @@ bool cptr(void *d) {
// CIR: %{{[0-9]+}} = cir.cast ptr_to_bool %[[DVAL]] : !cir.ptr<!void> -> !cir.bool
// LLVM-LABEL: define{{.*}} i1 @_Z4cptrPv(ptr {{.*}} %0)
-// LLVM: %[[ARG_STORAGE:.*]] = alloca ptr,
// LLVM: %[[RETVAL:.*]] = alloca i8,
+// LLVM: %[[ARG_STORAGE:.*]] = alloca ptr,
// LLVM: %[[X_STORAGE:.*]] = alloca i8,
// LLVM: store ptr %0, ptr %[[ARG_STORAGE]]
// LLVM: %[[LOADED_PTR:.*]] = load ptr, ptr %[[ARG_STORAGE]]
diff --git a/clang/test/CIR/CodeGen/class.cpp b/clang/test/CIR/CodeGen/class.cpp
index 3a31ee34f885cc..eb808e21a2ba3c 100644
--- a/clang/test/CIR/CodeGen/class.cpp
+++ b/clang/test/CIR/CodeGen/class.cpp
@@ -54,7 +54,7 @@ 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<!cir.ptr<!rec_Derived>>
// CIR: cir.store %[[ARG0]], %[[D_ADDR]]
-// CIR: %[[D_PTR:.*]] = cir.load align(8) %0
+// CIR: %[[D_PTR:.*]] = cir.load align(8) %[[D_ADDR]]
// CIR: %[[D_B_ADDR:.*]] = cir.get_member %[[D_PTR]][1] {name = "b"}
// CIR: %[[D_B:.*]] = cir.load align(4) %[[D_B_ADDR]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
index ae6ca57d4ce0e8..1423f087240d2f 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-eh.cpp
@@ -712,9 +712,9 @@ void test_flag_cleared_before_cond_cleanup() {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z37test_flag_cleared_before_cond_cleanupv(
-// LLVM: %[[AGG_TMP:.*]] = alloca %struct.Payload
// LLVM: %[[REF_TMP:.*]] = alloca %struct.Guard
// LLVM: %[[ACTIVE:.*]] = alloca i8
+// LLVM: %[[AGG_TMP:.*]] = alloca %struct.Payload
// LLVM: call void @_ZN5GuardC1Ev(ptr {{.*}} %[[REF_TMP]])
// LLVM: %[[COND:.*]] = invoke {{.*}} i1 @_ZN5GuardcvbEv(ptr {{.*}} %[[REF_TMP]])
// The clear dominates the arms, so both landingpads see an initialized flag.
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 8051ff3b2d5dfd..70dd8076a1c7eb 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper-eh.cpp
@@ -226,12 +226,12 @@ void APFixedPoint::add(int x) const {
// CIR: cir.return
// LLVM: define {{.*}} void @_ZNK12APFixedPoint3addEi(ptr {{.*}} %{{.*}}, i32 {{.*}} %{{.*}}){{.*}} personality ptr @__gxx_personality_v0
-// LLVM: %[[AGG_TMP:.*]] = alloca %struct.APInt
// LLVM: %[[THIS_ADDR:.*]] = alloca ptr
// LLVM: %[[X_ADDR:.*]] = alloca i32
// LLVM: %[[THISVAL:.*]] = alloca %struct.APInt
// LLVM: %[[CLEANUP_COND_TRUE:.*]] = alloca i8
// LLVM: %[[CLEANUP_COND_FALSE:.*]] = alloca i8
+// LLVM: %[[AGG_TMP:.*]] = alloca %struct.APInt
// LLVM: br i1 %{{.*}}, label %[[OUTER_TRUE:.*]], label %[[OUTER_END:.*]]
// LLVM: [[OUTER_TRUE]]:
// LLVM: br i1 %{{.*}}, label %[[COND_TRUE:.*]], label %[[COND_FALSE:.*]]
@@ -378,11 +378,11 @@ void makeEntry() {
// CIR: cir.return
// LLVM: define {{.*}} void @_Z9makeEntryv(){{.*}} personality ptr @__gxx_personality_v0
+// LLVM: %[[REF_TMP:.*]] = alloca %struct.Iter
+// LLVM: %[[CLEANUP_COND:.*]] = alloca i8
// LLVM: %[[AGG_TMP0:.*]] = alloca %struct.Path
// LLVM: %[[ENSURED_T:.*]] = alloca %struct.Entry
// LLVM: %[[ENSURED_F:.*]] = alloca %struct.Entry
-// LLVM: %[[REF_TMP:.*]] = alloca %struct.Iter
-// LLVM: %[[CLEANUP_COND:.*]] = alloca i8
// LLVM: %[[CALL:.*]] = invoke {{.*}} i1 @_ZN4ItercvbEv(ptr {{.*}} %[[REF_TMP]])
// LLVM: to label %[[CALL_CONT:.*]] unwind label %[[LPAD_ITER:.*]]
// LLVM: [[CALL_CONT]]:
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
index 0d7c64165ae53b..1d3ac68bc5a8fa 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional-with-wrapper.cpp
@@ -179,12 +179,12 @@ void APFixedPoint::add(int x) const {
// CIR: cir.return
// LLVM: define {{.*}} void @_ZNK12APFixedPoint3addEi(ptr {{.*}} %{{.*}}, i32 {{.*}} %{{.*}})
-// LLVM: %[[AGG_TMP:.*]] = alloca %struct.APInt
// LLVM: %[[THIS_ADDR:.*]] = alloca ptr
// LLVM: %[[X_ADDR:.*]] = alloca i32
// LLVM: %[[THISVAL:.*]] = alloca %struct.APInt
// LLVM: %[[CLEANUP_COND_TRUE:.*]] = alloca i8
// LLVM: %[[CLEANUP_COND_FALSE:.*]] = alloca i8
+// LLVM: %[[AGG_TMP:.*]] = alloca %struct.APInt
// LLVM: br i1 %{{.*}}, label %[[OUTER_TRUE:.*]], label %[[OUTER_END:.*]]
// LLVM: [[OUTER_TRUE]]:
// LLVM: br i1 %{{.*}}, label %[[COND_TRUE:.*]], label %[[COND_FALSE:.*]]
@@ -298,11 +298,11 @@ void makeEntry() {
// CIR: cir.return
// LLVM: define {{.*}} void @_Z9makeEntryv()
+// LLVM: %[[REF_TMP:.*]] = alloca %struct.Iter
+// LLVM: %[[CLEANUP_COND:.*]] = alloca i8
// LLVM: %[[AGG_TMP0:.*]] = alloca %struct.Path
// LLVM: %[[ENSURED_T:.*]] = alloca %struct.Entry
// LLVM: %[[ENSURED_F:.*]] = alloca %struct.Entry
-// LLVM: %[[REF_TMP:.*]] = alloca %struct.Iter
-// LLVM: %[[CLEANUP_COND:.*]] = alloca i8
// LLVM: %[[CALL:.*]] = call {{.*}} i1 @_ZN4ItercvbEv(ptr {{.*}} %[[REF_TMP]])
// LLVM: store i8 0, ptr %[[CLEANUP_COND]]
// LLVM: br i1 %[[CALL]], label %[[TRUE_BB:.*]], label %[[FALSE_BB:.*]]
diff --git a/clang/test/CIR/CodeGen/cleanup-conditional.cpp b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
index 67af679262f18a..1f86f1d1cd4831 100644
--- a/clang/test/CIR/CodeGen/cleanup-conditional.cpp
+++ b/clang/test/CIR/CodeGen/cleanup-conditional.cpp
@@ -277,8 +277,8 @@ int test_return_ternary(bool c) {
// CIR: cir.return %[[RET]] : !s32i
// LLVMCIR-LABEL: define dso_local noundef i32 @_Z19test_return_ternaryb(
-// LLVMCIR: %{{.*}} = alloca i8
// LLVMCIR: %[[RETVAL:.*]] = alloca i32
+// LLVMCIR: %{{.*}} = alloca i8
// LLVMCIR: %[[TMPA:.*]] = alloca %struct.A
// LLVMCIR: %[[ACTA:.*]] = alloca i8
// LLVMCIR: %[[TMPB:.*]] = alloca %struct.B
@@ -1057,9 +1057,9 @@ void test_flag_cleared_before_cond_cleanup() {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z37test_flag_cleared_before_cond_cleanupv(
-// LLVMCIR: %[[AGG_TMP:.*]] = alloca %struct.Payload
// LLVMCIR: %[[REF_TMP:.*]] = alloca %struct.Guard
// LLVMCIR: %[[ACTIVE:.*]] = alloca i8
+// LLVMCIR: %[[AGG_TMP:.*]] = alloca %struct.Payload
// OGCG: %[[REF_TMP:.*]] = alloca %struct.Guard
// OGCG: %[[AGG_TMP:.*]] = alloca %struct.Payload
// OGCG: %[[ACTIVE:.*]] = alloca i1
diff --git a/clang/test/CIR/CodeGen/complex.cpp b/clang/test/CIR/CodeGen/complex.cpp
index 1a3c7e6b6d3af7..db0a075adfe462 100644
--- a/clang/test/CIR/CodeGen/complex.cpp
+++ b/clang/test/CIR/CodeGen/complex.cpp
@@ -415,9 +415,9 @@ bool foo18(int _Complex a, int _Complex b) {
// LLVM-NEXT: %[[A_SLOT:.*]] = alloca i64, align 8
// LLVM-NEXT: store i64 %0, ptr %[[A_SLOT]], align 8
// LLVM-NEXT: %[[A_RELOAD:.*]] = load { i32, i32 }, ptr %[[A_SLOT]], align 4
+// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: %[[A_ADDR:.*]] = alloca { i32, i32 }, align 4
// LLVM-NEXT: %[[B_ADDR:.*]] = alloca { i32, i32 }, align 4
-// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: store { i32, i32 } %[[A_RELOAD]], ptr %[[A_ADDR]], align 4
// LLVM-NEXT: store { i32, i32 } %[[B_RELOAD]], ptr %[[B_ADDR]], align 4
// LLVM-NEXT: %[[COMPLEX_A:.*]] = load { i32, i32 }, ptr %[[A_ADDR]], align 4
@@ -474,9 +474,9 @@ bool foo19(double _Complex a, double _Complex b) {
// LLVM-NEXT: %[[A_RELOAD1:.*]] = load { double, double }, ptr %[[A_SLOT]], align 8
// LLVM-NEXT: store { double, double } %[[A_RELOAD1]], ptr %[[A_ADDR]], align 8
// LLVM-NEXT: %[[A_RELOAD2:.*]] = load { double, double }, ptr %[[A_ADDR]], align 8
+// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: %[[REAL_A_ADDR:.*]] = alloca { double, double }, align 8
// LLVM-NEXT: %[[REAL_B_ADDR:.*]] = alloca { double, double }, align 8
-// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: store { double, double } %[[A_RELOAD2]], ptr %[[REAL_A_ADDR]], align 8
// LLVM-NEXT: store { double, double } %[[B_RELOAD2]], ptr %[[REAL_B_ADDR]], align 8
// LLVM-NEXT: %[[COMPLEX_A:.*]] = load { double, double }, ptr %[[REAL_A_ADDR]], align 8
@@ -529,9 +529,9 @@ bool foo20(int _Complex a, int _Complex b) {
// LLVM-NEXT: %[[A_SLOT:.*]] = alloca i64, align 8
// LLVM-NEXT: store i64 %0, ptr %[[A_SLOT]], align 8
// LLVM-NEXT: %[[A_RELOAD:.*]] = load { i32, i32 }, ptr %[[A_SLOT]], align 4
+// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: %[[A_ADDR:.*]] = alloca { i32, i32 }, align 4
// LLVM-NEXT: %[[B_ADDR:.*]] = alloca { i32, i32 }, align 4
-// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: store { i32, i32 } %[[A_RELOAD]], ptr %[[A_ADDR]], align 4
// LLVM-NEXT: store { i32, i32 } %[[B_RELOAD]], ptr %[[B_ADDR]], align 4
// LLVM-NEXT: %[[COMPLEX_A:.*]] = load { i32, i32 }, ptr %[[A_ADDR]], align 4
@@ -587,9 +587,9 @@ bool foo21(double _Complex a, double _Complex b) {
// LLVM-NEXT: %[[A_RELOAD1:.*]] = load { double, double }, ptr %[[A_SLOT]], align 8
// LLVM-NEXT: store { double, double } %[[A_RELOAD1]], ptr %[[A_ADDR]], align 8
// LLVM-NEXT: %[[A_RELOAD2:.*]] = load { double, double }, ptr %[[A_ADDR]], align 8
+// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: %[[REAL_A_ADDR:.*]] = alloca { double, double }, align 8
// LLVM-NEXT: %[[REAL_B_ADDR:.*]] = alloca { double, double }, align 8
-// LLVM-NEXT: alloca i8, align 1
// LLVM-NEXT: store { double, double } %[[A_RELOAD2]], ptr %[[REAL_A_ADDR]], align 8
// LLVM-NEXT: store { double, double } %[[B_RELOAD2]], ptr %[[REAL_B_ADDR]], align 8
// LLVM-NEXT: %[[COMPLEX_A:.*]] = load { double, double }, ptr %[[REAL_A_ADDR]], align 8
@@ -1785,9 +1785,9 @@ bool eq_float_complex_and_float(float _Complex a, float b) {
return a == b;
}
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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>
@@ -1797,9 +1797,9 @@ bool eq_float_complex_and_float(float _Complex a, float b) {
// CIR: %[[RESULT:.*]] = cir.cmp eq %[[TMP_A]], %[[COMPLEX_B]] : !cir.complex<!cir.float>
// CIR: cir.store %[[RESULT]], %[[RET_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
+// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }
// LLVM: %[[B_ADDR:.*]] = alloca float
-// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: store { float, float } %[[ARG_0:.*]], ptr %[[A_ADDR]], align 4
// LLVM: store float %[[ARG_1:.*]], ptr %[[B_ADDR]], align 4
// LLVM: %[[TMP_A:.*]] = load { float, float }, ptr %[[A_ADDR]], align 4
@@ -1833,9 +1833,9 @@ bool eq_float_and_float_complex(float a, float _Complex b) {
return a == b;
}
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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
@@ -1845,9 +1845,9 @@ bool eq_float_and_float_complex(float a, float _Complex b) {
// CIR: %[[RESULT:.*]] = cir.cmp eq %[[COMPLEX_A]], %[[TMP_B]] : !cir.complex<!cir.float>
// CIR: cir.store %[[RESULT]], %[[RET_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
+// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: %[[A_ADDR:.*]] = alloca float
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }
-// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: store float %[[ARG_0:.*]], ptr %[[A_ADDR]], align 4
// LLVM: store { float, float } %[[ARG_1:.*]], ptr %[[B_ADDR]], align 4
// LLVM: %[[TMP_A:.*]] = load float, ptr %[[A_ADDR]], align 4
@@ -1881,9 +1881,9 @@ bool ne_float_complex_and_float(float _Complex a, float b) {
return a != b;
}
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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>
@@ -1893,9 +1893,9 @@ bool ne_float_complex_and_float(float _Complex a, float b) {
// CIR: %[[RESULT:.*]] = cir.cmp ne %[[TMP_A]], %[[COMPLEX_B]] : !cir.complex<!cir.float>
// CIR: cir.store %[[RESULT]], %[[RET_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
+// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }
// LLVM: %[[B_ADDR:.*]] = alloca float
-// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: store { float, float } %[[ARG_0:.*]], ptr %[[A_ADDR]], align 4
// LLVM: store float %[[ARG_1:.*]], ptr %[[B_ADDR]], align 4
// LLVM: %[[TMP_A:.*]] = load { float, float }, ptr %[[A_ADDR]], align 4
@@ -1929,9 +1929,9 @@ bool ne_float_and_float_complex(float a, float _Complex b) {
return a != b;
}
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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
@@ -1941,9 +1941,9 @@ bool ne_float_and_float_complex(float a, float _Complex b) {
// CIR: %[[RESULT:.*]] = cir.cmp ne %[[COMPLEX_A]], %[[TMP_B]] : !cir.complex<!cir.float>
// CIR: cir.store %[[RESULT]], %[[RET_ADDR]] : !cir.bool, !cir.ptr<!cir.bool>
+// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: %[[A_ADDR:.*]] = alloca float
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }
-// LLVM: %[[RET_ADDR:.*]] = alloca i8
// LLVM: store float %[[ARG_0:.*]], ptr %[[A_ADDR]], align 4
// LLVM: store { float, float } %[[ARG_1:.*]], ptr %[[B_ADDR]], align 4
// LLVM: %[[TMP_A:.*]] = load float, ptr %[[A_ADDR]], align 4
diff --git a/clang/test/CIR/CodeGen/cxx-construct-lvalue.cpp b/clang/test/CIR/CodeGen/cxx-construct-lvalue.cpp
index 51d8be2b417aa3..4006c217c6ad3b 100644
--- a/clang/test/CIR/CodeGen/cxx-construct-lvalue.cpp
+++ b/clang/test/CIR/CodeGen/cxx-construct-lvalue.cpp
@@ -1,7 +1,7 @@
// RUN: %clang_cc1 -std=c++03 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
// RUN: FileCheck --input-file=%t.cir %s --check-prefix=CIR
// RUN: %clang_cc1 -std=c++03 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t-cir.ll
-// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefix=LLVM
+// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefixes=LLVM,LLVMCIR
// RUN: %clang_cc1 -std=c++03 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
@@ -13,8 +13,8 @@ struct Pt {
int tempObj(int i) { return Pt(i, i).v; }
// CIR-LABEL: cir.func {{.*}}@_Z7tempObji(%arg0: !s32i
-// CIR: %[[I:.*]] = cir.alloca "i"
// CIR: %[[RET:.*]] = cir.alloca "__retval"
+// CIR: %[[I:.*]] = cir.alloca "i"
// CIR: %[[TMP:.*]] = cir.alloca "tmp"
// CIR: cir.store %arg0, %[[I]]
// CIR: %[[A:.*]] = cir.load align(4) %[[I]]
@@ -27,6 +27,8 @@ int tempObj(int i) { return Pt(i, i).v; }
// CIR: cir.return %[[RES]]
// LLVM-LABEL: define {{.*}}i32 @_Z7tempObji
+// Classic codegen doesn't alloca for a return slot.
+// LLVMCIR: %{{.+}} = alloca i32, align 4
// LLVM: %[[I_ADDR:.*]] = alloca i32
// LLVM: %[[TMP:.*]] = alloca %struct.Pt
// LLVM: store i32 %{{.*}}, ptr %[[I_ADDR]]
@@ -44,8 +46,8 @@ struct Conv {
int construct(int i) { return Conv(i).y; }
// CIR-LABEL: cir.func {{.*}}@_Z9constructi(%arg0: !s32i
-// CIR: %[[I:.*]] = cir.alloca "i"
// CIR: %[[RET:.*]] = cir.alloca "__retval"
+// CIR: %[[I:.*]] = cir.alloca "i"
// CIR: %[[TMP:.*]] = cir.alloca "tmp"
// CIR: cir.store %arg0, %[[I]]
// CIR: %[[A:.*]] = cir.load align(4) %[[I]]
@@ -57,6 +59,7 @@ int construct(int i) { return Conv(i).y; }
// CIR: cir.return %[[RES]]
// LLVM-LABEL: define {{.*}}i32 @_Z9constructi
+// LLVMCIR: %{{.+}} = alloca i32, align 4
// LLVM: %[[I_ADDR:.*]] = alloca i32
// LLVM: %[[TMP:.*]] = alloca %struct.Conv
// LLVM: store i32 %{{.*}}, ptr %[[I_ADDR]]
diff --git a/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp b/clang/test/CIR/CodeGen/cxx-conversion-operators.cpp
index 21dfbf23346458..6e703d5a414152 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<!cir.ptr<!rec_out_of_line_operator>>
// CIR: %[[RETVAL:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_out_of_line_operator>>
// 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
@@ -52,8 +52,8 @@ void test() {
// CIR: }
// CIR: cir.func no_inline comdat alignment(2) linkonce_odr @_ZNK15inline_operatorcviEv(%[[INLINE_THIS_ARG:.+]]: !cir.ptr<!rec_inline_operator>{{.*}}) -> (!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: %[[INLINE_THIS_ALLOCA:.+]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_inline_operator>>
// 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
@@ -63,8 +63,8 @@ void test() {
// CIR: }
// LLVM: define dso_local noundef i32 @_ZN20out_of_line_operatorcviEv(ptr {{.*}} %[[PARAM0:.+]])
-// LLVM: %[[THIS_ALLOCA:.+]] = alloca ptr,
// LLVM: %[[RETVAL:.+]] = alloca i32,
+// LLVM: %[[THIS_ALLOCA:.+]] = alloca ptr,
// LLVM: store ptr %[[PARAM0]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS_LOAD:.+]] = load ptr, ptr %[[THIS_ALLOCA]]
// LLVM: store i32 123, ptr %[[RETVAL]]
@@ -85,8 +85,8 @@ void test() {
// LLVM: }
// LLVM: define linkonce_odr noundef i32 @_ZNK15inline_operatorcviEv(ptr {{.*}} %[[INLINE_PARAM0:.+]])
-// LLVM: %[[INLINE_THIS_ALLOCA:.+]] = alloca ptr,
// LLVM: %[[INLINE_RETVAL:.+]] = alloca i32,
+// LLVM: %[[INLINE_THIS_ALLOCA:.+]] = alloca ptr,
// LLVM: store ptr %[[INLINE_PARAM0]], ptr %[[INLINE_THIS_ALLOCA]]
// LLVM: %[[INLINE_THIS_LOAD:.+]] = load ptr, ptr %[[INLINE_THIS_ALLOCA]]
// LLVM: store i32 987, ptr %[[INLINE_RETVAL]]
diff --git a/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp b/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
index 998b14c13eeb51..8bbee2fb3d9ef0 100644
--- a/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
+++ b/clang/test/CIR/CodeGen/delete-array-throwing-dtor.cpp
@@ -106,7 +106,8 @@ void test_delete_array_throwing_dtor(ThrowingDtor *ptr) {
// LLVM: define {{.*}} void @_Z31test_delete_array_throwing_dtorP12ThrowingDtor(ptr {{.*}})
//
-// `__array_idx` alloca and the function-entry null check.
+// Parameter and `__array_idx` allocas, and the function-entry null check.
+// LLVM: %[[P_ADDR:[0-9]+]] = alloca ptr
// LLVM: %[[ARR_IDX:[0-9]+]] = alloca ptr
// LLVM: %[[PTR:.*]] = load ptr
// LLVM: %[[NOT_NULL:.*]] = icmp ne ptr %[[PTR]], null
diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp
index 6335293f3abfff..09597febfe8602 100644
--- a/clang/test/CIR/CodeGen/derived-to-base.cpp
+++ b/clang/test/CIR/CodeGen/derived-to-base.cpp
@@ -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<!cir.ptr<!rec_Derived>>
// CIR: %[[BASE_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_Base>>
+// 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 nonnull %[[DERIVED]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
@@ -81,6 +81,7 @@ Base *returnBaseFromDerived(Derived* derived) {
// CIR: cir.return %[[BASE]] : !cir.ptr<!rec_Base>
// LLVM: define {{.*}} ptr @_Z21returnBaseFromDerivedP7Derived(ptr {{.*}} %[[DERIVED_ARG:.*]])
+// LLVM: %[[BASE_ADDR:.*]] = alloca ptr
// LLVM: %[[DERIVED_ADDR:.*]] = alloca ptr
// LLVM: store ptr %[[DERIVED_ARG]], ptr %[[DERIVED_ADDR]]
// LLVM: %[[DERIVED:.*]] = load ptr, ptr %[[DERIVED_ADDR]]
diff --git a/clang/test/CIR/CodeGen/destructors.cpp b/clang/test/CIR/CodeGen/destructors.cpp
index 44da623de766ec..25e0c6792798c2 100644
--- a/clang/test/CIR/CodeGen/destructors.cpp
+++ b/clang/test/CIR/CodeGen/destructors.cpp
@@ -104,9 +104,9 @@ void test_array_destructor() {
// LLVM: define{{.*}} void @_Z21test_array_destructorv()
-// LLVM: %[[ARR_CUR:.*]] = alloca ptr
// LLVM: %[[ARR:.*]] = alloca [5 x %struct.array_element]
// LLVM: %[[TMP:.*]] = alloca ptr
+// LLVM: %[[ARR_CUR:.*]] = alloca ptr
// LLVM: %[[ARR_PTR:.*]] = getelementptr %struct.array_element, ptr %[[ARR]], i32 0
// LLVM: store ptr %[[ARR_PTR]], ptr %[[TMP]]
// LLVM: %[[END_PTR:.*]] = getelementptr %struct.array_element, ptr %[[ARR_PTR]], i64 5
diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp
index da10ad4ed5ba38..7402be349cbd36 100644
--- a/clang/test/CIR/CodeGen/dtors.cpp
+++ b/clang/test/CIR/CodeGen/dtors.cpp
@@ -319,8 +319,8 @@ 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<!cir.ptr<!rec_G>>
// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[OBJ:.*]] = cir.alloca "obj" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_G>>
// CIR: cir.store %[[ARG0]], %[[OBJ]]
// CIR: cir.scope {
// CIR: %[[REF_TMP0:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!rec_G>
@@ -358,11 +358,11 @@ int test_temp_in_condition(G &obj) {
// CIR: cir.return %[[RETVAL]]
// LLVM: define {{.*}} i32 @_Z22test_temp_in_conditionR1G(ptr {{.*}} %[[ARG0:.*]])
+// LLVM: %[[RET_ADDR:.*]] = alloca i32
+// LLVM: %[[OBJ:.*]] = alloca ptr
// LLVM: %[[REF_TMP0:.*]] = alloca %struct.G
// LLVM: %[[REF_TMP1:.*]] = alloca %struct.G
// LLVM: %[[TMP_RESULT:.*]] = alloca i8
-// LLVM: %[[OBJ:.*]] = alloca ptr
-// LLVM: %[[RET_ADDR:.*]] = alloca i32
// LLVM: store ptr %[[ARG0]], ptr %[[OBJ]]
// LLVM: br label %[[SCOPE_BEGIN:.*]]
// LLVM: [[SCOPE_BEGIN]]:
diff --git a/clang/test/CIR/CodeGen/ehspec.cpp b/clang/test/CIR/CodeGen/ehspec.cpp
index d33951b6add47f..2027f7a2d42366 100644
--- a/clang/test/CIR/CodeGen/ehspec.cpp
+++ b/clang/test/CIR/CodeGen/ehspec.cpp
@@ -54,6 +54,25 @@ void target() throw(int) {
// OGCG: {{^}}[[RESUME]]:
// OGCG: resume { ptr, i32 } %{{.*}}
+int target_value(int a) throw(int) {
+ if (a)
+ return a;
+ external();
+ return 0;
+}
+
+// CIR-LABEL: cir.func{{.*}} @_Z12target_valuei(
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
+// CIR-NEXT: cir.try {
+// CIR-NEXT: cir.store %{{.+}}, %[[A]] : !s32i, !cir.ptr<!s32i>
+
+// LLVM-LABEL: define dso_local noundef i32 @_Z12target_valuei(i32 noundef %{{.+}})
+// LLVM: %[[RETVAL:.*]] = alloca i32, align 4
+// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
+// LLVM: store i32 %{{.+}}, ptr %[[A]], align 4
+// LLVM: store i32 %{{.+}}, ptr %[[RETVAL]], align 4
+
void target2() throw() {
external();
}
diff --git a/clang/test/CIR/CodeGen/fixed-point-arith.cpp b/clang/test/CIR/CodeGen/fixed-point-arith.cpp
index 83d0d36e5776a7..1e1f11860dd806 100644
--- a/clang/test/CIR/CodeGen/fixed-point-arith.cpp
+++ b/clang/test/CIR/CodeGen/fixed-point-arith.cpp
@@ -1,15 +1,15 @@
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -ffixed-point -fclangir -emit-cir %s -o %t.cir
// RUN: FileCheck --input-file=%t.cir %s --check-prefix=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -ffixed-point -fclangir -emit-llvm %s -o %t-cir.ll
-// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefix=LLVM
+// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefixes=LLVM,LLVMCIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -ffixed-point -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM,OGCG
extern "C" {
// CIR-LABEL: cir.func {{.*}}@add(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -18,6 +18,8 @@ extern "C" {
// LLVM-LABEL: define {{.*}}i32 @add(
// OGCG-NEXT: entry:
+// Classic codegen doesn't alloca for a return slot.
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -29,9 +31,9 @@ _Accum add(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@add2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_A:.*]] = cir.cast integral %[[LOAD_A]] : !s32i -> !cir.int<s, 47>
@@ -45,6 +47,7 @@ _Accum add(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @add2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -60,9 +63,9 @@ _Accum add2(int a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@sub(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -71,6 +74,7 @@ _Accum add2(int a, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @sub(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -82,9 +86,9 @@ _Accum sub(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@sub2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -98,6 +102,7 @@ _Accum sub(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @sub2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -113,9 +118,9 @@ _Accum sub2(_Accum a, short f) {
}
// CIR-LABEL: cir.func {{.*}}@mul(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -125,6 +130,7 @@ _Accum sub2(_Accum a, short f) {
// LLVM-LABEL: define {{.*}}i32 @mul(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -136,9 +142,9 @@ _Accum mul(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@mul2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[S:.*]] = cir.alloca "s" align(2) init : !cir.ptr<!u16i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_S:.*]] = cir.load align(2) %[[S]] : !cir.ptr<!u16i>, !u16i
// CIR-NEXT: %[[WIDEN_S:.*]] = cir.cast integral %[[LOAD_S]] : !u16i -> !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
@@ -154,6 +160,7 @@ _Accum mul(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @mul2(i16
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[S:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_S:.*]] = load i16, ptr %[[S]], align 2
@@ -170,9 +177,9 @@ _Accum mul2(unsigned short s, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@div(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -182,6 +189,7 @@ _Accum mul2(unsigned short s, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @div(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -193,9 +201,9 @@ _Accum div(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@div2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(4) init : !cir.ptr<!cir.float>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[FLOAT_A:.*]] = cir.cast int_to_float %[[LOAD_A]] : !s32i -> !cir.float
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.fp<3.05175781E-5> : !cir.float
@@ -209,6 +217,7 @@ _Accum div(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @div2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca float, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -223,9 +232,9 @@ _Accum div2(_Accum a, float f) {
}
// CIR-LABEL: cir.func {{.*}}@umul(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!u32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!u32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!u32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<16> : !u32i
@@ -234,6 +243,7 @@ _Accum div2(_Accum a, float f) {
// LLVM-LABEL: define {{.*}}i32 @umul(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -244,9 +254,9 @@ unsigned _Accum umul(unsigned _Accum a, unsigned _Accum b) {
}
// CIR-LABEL: cir.func {{.*}}@cmp(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -255,6 +265,7 @@ unsigned _Accum umul(unsigned _Accum a, unsigned _Accum b) {
// LLVM-LABEL: define {{.*}}i1 @cmp(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i8, align 1
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -266,9 +277,9 @@ bool cmp(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@cmp2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -277,6 +288,7 @@ bool cmp(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i1 @cmp2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i8, align 1
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -288,9 +300,9 @@ bool cmp2(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@cmp3(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
@@ -299,6 +311,7 @@ bool cmp2(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i1 @cmp3(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i8, align 1
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -310,8 +323,8 @@ bool cmp3(_Accum a, _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@shl(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[LOAD_A]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
@@ -319,6 +332,7 @@ bool cmp3(_Accum a, _Fract f) {
// LLVM-LABEL: define {{.*}}i32 @shl(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = shl i32 %[[LOAD_A]], 2
@@ -327,9 +341,9 @@ _Accum shl(_Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@shl2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[C:.*]] = cir.alloca "c" align(1) init : !cir.ptr<!u8i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_C:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!u8i>, !u8i
// CIR-NEXT: %[[WIDEN_C:.*]] = cir.cast integral %[[LOAD_C]] : !u8i -> !s32i
@@ -338,6 +352,7 @@ _Accum shl(_Accum a) {
// LLVM-LABEL: define {{.*}}i32 @shl2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[C:.*]] = alloca i8, align 1
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -349,9 +364,9 @@ _Accum shl2(_Accum a, unsigned char c) {
}
// CIR-LABEL: cir.func {{.*}}@shl3(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[C:.*]] = cir.alloca "c" align(1) init : !cir.ptr<!u8i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_C:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!u8i>, !u8i
// CIR-NEXT: %[[WIDEN_C:.*]] = cir.cast integral %[[LOAD_C]] : !u8i -> !s32i
@@ -360,6 +375,7 @@ _Accum shl2(_Accum a, unsigned char c) {
// LLVM-LABEL: define {{.*}}i16 @shl3(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[C:.*]] = alloca i8, align 1
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
@@ -372,8 +388,8 @@ _Fract shl3(_Fract f, unsigned char c) {
}
// CIR-LABEL: cir.func {{.*}}@shr(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_A]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
@@ -381,6 +397,7 @@ _Fract shl3(_Fract f, unsigned char c) {
// LLVM-LABEL: define {{.*}}i32 @shr(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i32 %[[LOAD_A]], 2
@@ -389,9 +406,9 @@ _Accum shr(_Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@shr2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init : !cir.ptr<!u32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_U:.*]] = cir.load align(4) %[[U]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_A]] : !s32i, %[[LOAD_U]] : !u32i) -> !s32i
@@ -399,6 +416,7 @@ _Accum shr(_Accum a) {
// LLVM-LABEL: define {{.*}}i32 @shr2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[U:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -409,9 +427,9 @@ _Accum shr2(_Accum a, unsigned u) {
}
// CIR-LABEL: cir.func {{.*}}@shr3(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init : !cir.ptr<!u32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_U:.*]] = cir.load align(4) %[[U]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_F]] : !s16i, %[[LOAD_U]] : !u32i) -> !s16i
@@ -419,6 +437,7 @@ _Accum shr2(_Accum a, unsigned u) {
// LLVM-LABEL: define {{.*}}i16 @shr3(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[U:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
@@ -430,8 +449,8 @@ _Fract shr3(_Fract f, unsigned u) {
}
// CIR-LABEL: cir.func {{.*}}@inc(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s32i
@@ -442,6 +461,7 @@ _Fract shr3(_Fract f, unsigned u) {
// LLVM-LABEL: define {{.*}}i32 @inc(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[INC:.*]] = sub i32 %[[LOAD_A]], -32768
@@ -450,8 +470,8 @@ _Accum inc(_Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@inc2(
-// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
+// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s16i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s16i
@@ -462,6 +482,7 @@ _Accum inc(_Accum a) {
// LLVM-LABEL: define {{.*}}i16 @inc2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[A:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i16, ptr %[[A]], align 2
// LLVM-NEXT: %[[INC:.*]] = sub i16 %[[LOAD_A]], -32768
@@ -470,8 +491,8 @@ _Fract inc2(_Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@dec(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s32i
@@ -482,6 +503,7 @@ _Fract inc2(_Fract f) {
// LLVM-LABEL: define {{.*}}i32 @dec(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[DEC:.*]] = add i32 %[[LOAD_A]], -32768
@@ -490,8 +512,8 @@ _Accum dec(_Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@dec2(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!s16i>
// CIR: %[[LOAD_A:.*]] = cir.load align(2) %[[A]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s16i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s16i
@@ -502,6 +524,7 @@ _Accum dec(_Accum a) {
// LLVM-LABEL: define {{.*}}i16 @dec2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[A:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i16, ptr %[[A]], align 2
// LLVM-NEXT: %[[DEC:.*]] = add i16 %[[LOAD_A]], -32768
@@ -510,9 +533,9 @@ _Fract dec2(_Fract a) {
}
// CIR-LABEL: cir.func {{.*}}@satAdd(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[ADD:.*]] = cir.add sat %[[LOAD_A]], %[[LOAD_B]] : !s32i
@@ -520,6 +543,7 @@ _Fract dec2(_Fract a) {
// LLVM-LABEL: define {{.*}}i32 @satAdd(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -530,9 +554,9 @@ _Sat _Accum satAdd(_Sat _Accum a, _Accum b) {
}
// CIR-LABEL: cir.func {{.*}}@satSub(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SUB:.*]] = cir.sub sat %[[LOAD_A]], %[[LOAD_B]] : !s32i
@@ -540,6 +564,7 @@ _Sat _Accum satAdd(_Sat _Accum a, _Accum b) {
// LLVM-LABEL: define {{.*}}i32 @satSub(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -550,9 +575,9 @@ _Sat _Accum satSub(_Sat _Accum a, _Sat _Accum b) {
}
// CIR-LABEL: cir.func {{.*}}@satMul(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
@@ -561,6 +586,7 @@ _Sat _Accum satSub(_Sat _Accum a, _Sat _Accum b) {
// LLVM-LABEL: define {{.*}}i32 @satMul(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -571,9 +597,9 @@ _Sat _Accum satMul(_Sat _Accum a, _Sat _Accum b) {
}
// CIR-LABEL: cir.func {{.*}}@satDiv(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
@@ -582,6 +608,7 @@ _Sat _Accum satMul(_Sat _Accum a, _Sat _Accum b) {
// LLVM-LABEL: define {{.*}}i32 @satDiv(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
@@ -592,8 +619,8 @@ _Sat _Accum satDiv(_Sat _Accum a, _Sat _Accum b) {
}
// CIR-LABEL: cir.func {{.*}}@satShl(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.call_llvm_intrinsic "sshl.sat" %[[LOAD_A]], %[[SHIFT_NUM]] : (!s32i, !s32i) -> !s32i
@@ -601,6 +628,7 @@ _Sat _Accum satDiv(_Sat _Accum a, _Sat _Accum b) {
// LLVM-LABEL: define {{.*}}i32 @satShl(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = call i32 @llvm.sshl.sat.i32(i32 %[[LOAD_A]], i32 2)
@@ -609,9 +637,9 @@ _Sat _Accum satShl(_Sat _Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@satShl2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[C:.*]] = cir.alloca "c" align(1) init : !cir.ptr<!s8i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_A:.*]] = cir.load align(2) %[[A]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_C:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!s8i>, !s8i
// CIR-NEXT: %[[WIDEN_C:.*]] = cir.cast integral %[[LOAD_C]] : !s8i -> !s32i
@@ -622,6 +650,7 @@ _Sat _Accum satShl(_Sat _Accum a) {
// LLVM-LABEL: define {{.*}}i16 @satShl2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[C:.*]] = alloca i8, align 1
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
@@ -634,8 +663,8 @@ _Sat _Fract satShl2(_Sat _Fract a, char c) {
}
// CIR-LABEL: cir.func {{.*}}@satShr(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_A]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
@@ -643,6 +672,7 @@ _Sat _Fract satShl2(_Sat _Fract a, char c) {
// LLVM-LABEL: define {{.*}}i32 @satShr(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i32 %[[LOAD_A]], 2
@@ -651,9 +681,9 @@ _Sat _Accum satShr(_Sat _Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@satShr2(
+// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
-// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_I:.*]] = cir.load align(4) %[[I]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_F]] : !s16i, %[[LOAD_I]] : !s32i) -> !s16i
@@ -661,6 +691,7 @@ _Sat _Accum satShr(_Sat _Accum a) {
// LLVM-LABEL: define {{.*}}i16 @satShr2(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[I:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
@@ -673,8 +704,8 @@ _Sat _Fract satShr2(_Sat _Fract f, int i) {
}
// CIR-LABEL: cir.func {{.*}}@satInc(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !cir.int<s, 47>
@@ -692,6 +723,7 @@ _Sat _Fract satShr2(_Sat _Fract f, int i) {
// LLVM-LABEL: define {{.*}}i32 @satInc(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i32, align 4
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[ADD:.*]] = call i32 @llvm.ssub.sat.i32(i32 %[[LOAD_A]], i32 -32768)
@@ -701,8 +733,8 @@ _Sat _Accum satInc(_Sat _Accum a) {
}
// CIR-LABEL: cir.func {{.*}}@satDec(
-// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
+// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !cir.int<s, 31>
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !cir.int<s, 31>
@@ -720,6 +752,7 @@ _Sat _Accum satInc(_Sat _Accum a) {
// LLVM-LABEL: define {{.*}}i16 @satDec(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[ADD:.*]] = call i16 @llvm.sadd.sat.i16(i16 %[[LOAD_F]], i16 -32768)
@@ -730,8 +763,8 @@ _Sat _Fract satDec(_Sat _Fract f) {
}
// CIR-LABEL: cir.func {{.*}}@satIncUFract(
-// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!u16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!u16i>
+// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!u16i>
// CIR: %[[LOAD_A:.*]] = cir.load align(2) %[[A]] : !cir.ptr<!u16i>, !u16i
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<16> : !s32i
@@ -749,6 +782,7 @@ _Sat _Fract satDec(_Sat _Fract f) {
// LLVM-LABEL: define {{.*}}i16 @satIncUFract(
// OGCG-NEXT: entry:
+// LLVMCIR-NEXT: %{{.+}} = alloca i16, align 2
// LLVM-NEXT: %[[A:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i16, ptr %[[A]], align 2
// LLVM-NEXT: %[[ADD:.*]] = call i16 @llvm.uadd.sat.i16(i16 %[[LOAD_A]], i16 -1)
diff --git a/clang/test/CIR/CodeGen/gnu-ptr-math.c b/clang/test/CIR/CodeGen/gnu-ptr-math.c
index 18d69e225377df..aa7cb8fe12f8bb 100644
--- a/clang/test/CIR/CodeGen/gnu-ptr-math.c
+++ b/clang/test/CIR/CodeGen/gnu-ptr-math.c
@@ -9,16 +9,16 @@ typedef int(*fptr)(int, double);
vptr vptr_add(vptr p) {
// CIR-LABEL: vptr_add
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[RET]]
// LLVM-LABEL: vptr_add
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG]]
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], i64 3
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
@@ -28,16 +28,16 @@ vptr vptr_add(vptr p) {
vptr vptr_sub(vptr p) {
// CIR-LABEL: vptr_sub
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[RET]]
// LLVM-LABEL: vptr_sub
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG]]
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], i64 -2
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
@@ -47,16 +47,16 @@ vptr vptr_sub(vptr p) {
vptr vptr_inc(vptr p) {
// CIR-LABEL: vptr_inc
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[ARG]]
// LLVM-LABEL: vptr_inc
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG]]
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], {{.*}} 1
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
@@ -65,16 +65,16 @@ vptr vptr_inc(vptr p) {
}
vptr vptr_dec(vptr p) {
// CIR-LABEL: vptr_dec
- // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!void>>
// CIR: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!void>>
+ // CIR: %[[ARG:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[RET]]
// LLVM-LABEL: vptr_dec
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG]]
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], {{.*}} -1
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
@@ -84,16 +84,16 @@ vptr vptr_dec(vptr p) {
fptr fptr_add(fptr p) {
// CIR-LABEL: fptr_add
- // 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:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[RET]]
// LLVM-LABEL: fptr_add
+ // LLVM_CIR: %[[RET:.*]] = alloca ptr
// LLVM: %[[ARG:.*]] = alloca ptr
- // LLVM-CIR: %[[RET:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG]]
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], i64 3
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
@@ -103,16 +103,16 @@ fptr fptr_add(fptr p) {
fptr fptr_sub(fptr p) {
// CIR-LABEL: fptr_sub
- // 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:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[RET]]
// LLVM-LABEL: fptr_sub
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG]]
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], i64 -2
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
@@ -122,16 +122,16 @@ fptr fptr_sub(fptr p) {
fptr fptr_inc(fptr p) {
// CIR-LABEL: fptr_inc
- // 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:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[ARG]]
// LLVM-LABEL: fptr_inc
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], {{.*}} 1
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
// LLVM_OG: store ptr %[[STRIDE]], ptr %[[ARG]]
@@ -139,16 +139,16 @@ fptr fptr_inc(fptr p) {
}
fptr fptr_dec(fptr p) {
// CIR-LABEL: fptr_dec
- // 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:.*]] = cir.alloca "p" {{.*}} init : !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]]
// CIR: cir.store {{.*}}%[[STRIDE]], %[[RET]]
// LLVM-LABEL: fptr_dec
- // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM_CIR: %[[RET:.*]] = alloca ptr
+ // LLVM: %[[ARG:.*]] = alloca ptr
// LLVM: %[[STRIDE:.*]] = getelementptr {{.*}}i8, ptr %[[ARG_LOAD]], {{.*}} -1
// LLVM_CIR: store ptr %[[STRIDE:.*]], ptr %[[RET]]
// LLVM_OG: ret ptr %[[STRIDE]]
diff --git a/clang/test/CIR/CodeGen/if.cpp b/clang/test/CIR/CodeGen/if.cpp
index 189623e36c4230..12c35a175650be 100644
--- a/clang/test/CIR/CodeGen/if.cpp
+++ b/clang/test/CIR/CodeGen/if.cpp
@@ -16,11 +16,11 @@ int if0(bool a) {
// CIR: cir.func{{.*}} @_Z3if0b(%arg0: !cir.bool {{.*}} loc({{.*}})) -> (!s32i{{.*}})
// CIR: cir.scope {
-// CIR: %4 = cir.load{{.*}} %0 : !cir.ptr<!cir.bool>, !cir.bool
+// CIR: %4 = cir.load{{.*}} %1 : !cir.ptr<!cir.bool>, !cir.bool
// CIR-NEXT: cir.if %4 {
// CIR-NEXT: %5 = cir.const #cir.int<2> : !s32i
-// CIR-NEXT: cir.store{{.*}} %5, %1 : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: %6 = cir.load{{.*}} %1 : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: cir.store{{.*}} %5, %0 : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: %6 = cir.load{{.*}} %0 : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: cir.return %6 : !s32i
// CIR-NEXT: }
// CIR-NEXT: }
@@ -29,18 +29,18 @@ int if0(bool a) {
// LLVM: define{{.*}} i32 @_Z3if0b(i1 noundef zeroext %0)
// LLVM: br label %[[ENTRY:.*]]
// LLVM: [[ENTRY]]:
-// LLVM: %6 = load i8, ptr %2, align 1
+// LLVM: %6 = load i8, ptr %3, align 1
// LLVM: %7 = trunc i8 %6 to i1
// LLVM: br i1 %7, label %[[THEN:.*]], label %[[END:.*]]
// LLVM: [[THEN]]:
-// LLVM: store i32 2, ptr %3, align 4
-// LLVM: %9 = load i32, ptr %3, align 4
+// LLVM: store i32 2, ptr %2, align 4
+// LLVM: %9 = load i32, ptr %2, align 4
// LLVM: ret i32 %9
// LLVM: [[END]]:
// LLVM: br label %[[LABEL4:.*]]
// LLVM: [[LABEL4]]:
-// LLVM: store i32 3, ptr %3, align 4
-// LLVM: %12 = load i32, ptr %3, align 4
+// LLVM: store i32 3, ptr %2, align 4
+// LLVM: %12 = load i32, ptr %2, align 4
// LLVM: ret i32 %12
// OGCG: define{{.*}} i32 @_Z3if0b(i1 noundef zeroext %a)
@@ -286,8 +286,8 @@ int if_init() {
// CIR: }
// LLVM: define{{.*}} i32 @_Z7if_initv()
-// LLVM: %[[X:.*]] = alloca i32, align 4
// LLVM: %[[RETVAL:.*]] = alloca i32, align 4
+// LLVM: %[[X:.*]] = alloca i32, align 4
// LLVM: store i32 42, ptr %[[X]], align 4
// LLVM: %[[X_VAL:.*]] = load i32, ptr %[[X]], align 4
// LLVM: %[[COND:.*]] = icmp ne i32 %[[X_VAL]], 0
diff --git a/clang/test/CIR/CodeGen/inline-asm.c b/clang/test/CIR/CodeGen/inline-asm.c
index 0060d78a5ea325..9c556753b4a17f 100644
--- a/clang/test/CIR/CodeGen/inline-asm.c
+++ b/clang/test/CIR/CodeGen/inline-asm.c
@@ -108,9 +108,9 @@ void empty6(int x) {
// CIR-NEXT: {"addl $$42, $1" "=r,r,~{dirflag},~{fpsr},~{flags}"}) -> !s32i
// CIR-NEXT: cir.store{{.*}} %[[ASM_RES]], %[[A]] : !s32i, !cir.ptr<!s32i>
// LLVM: define{{.*}}@add1
-// LLVM: %[[X:.*]] = alloca i32
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca i32
+// LLVM: %[[X:.*]] = alloca i32
// LLVM: %[[A:.*]] = alloca i32
// LLVM: %[[X_LOAD:.*]] = load i32, ptr %[[X]]
// LLVM: %[[ASM_RES:.*]] = call i32 asm "addl $$42, $1", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %[[X_LOAD]])
@@ -135,6 +135,8 @@ unsigned add1(unsigned int x) {
// CIR-NEXT: {"addl $$42, $0" "=r,0,~{dirflag},~{fpsr},~{flags}"}) -> !u32i
// CIR-NEXT: cir.store{{.*}} %[[ASM_RES]], %[[X]] : !u32i, !cir.ptr<!u32i>
// LLVM: define{{.*}}@add2
+// Classic codegen doesn't alloca for a return slot.
+// CIRLLVMONLY: alloca i32
// LLVM: %[[X:.*]] = alloca i32
// LLVM: %[[X_LOAD:.*]] = load i32, ptr %[[X]]
// LLVM: %[[ASM_RES:.*]] = call i32 asm "addl $$42, $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %[[X_LOAD]])
@@ -156,6 +158,8 @@ unsigned add2(unsigned int x) {
// CIR-NEXT: {"addl $$42, $0 \0A\09 subl $$1, $0 \0A\09 imul $$2, $0" "=r,0,~{dirflag},~{fpsr},~{flags}"}) -> !u32i
// CIR-NEXT: cir.store{{.*}} %[[ASM_RES]], %[[X]] : !u32i, !cir.ptr<!u32i>
// LLVM: define{{.*}}@add3
+// Classic codegen doesn't alloca for a return slot.
+// CIRLLVMONLY: alloca i32
// LLVM: %[[X:.*]] = alloca i32
// LLVM: %[[X_LOAD:.*]] = load i32, ptr %[[X]]
// LLVM: %[[ASM_RES:.*]] = call i32 asm "addl $$42, $0 \0A\09 subl $$1, $0 \0A\09 imul $$2, $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %[[X_LOAD]])
@@ -199,10 +203,10 @@ void add4(int *x) {
// CIR-NEXT: {"flds $1; flds $2; faddp" "=&{st},imr,imr,~{dirflag},~{fpsr},~{flags}"}) -> !cir.float
// CIR-NEXT: cir.store{{.*}} %[[ASM_RES]], %[[R]] : !cir.float, !cir.ptr<!cir.float>
// LLVM: define{{.*}}@add5
-// LLVM: %[[X:.*]] = alloca float
-// LLVM: %[[Y:.*]] = alloca float
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca float
+// LLVM: %[[X:.*]] = alloca float
+// LLVM: %[[Y:.*]] = alloca float
// LLVM: %[[R:.*]] = alloca float
// LLVM: %[[X_LOAD:.*]] = load float, ptr %[[X]]
// LLVM: %[[Y_LOAD:.*]] = load float, ptr %[[Y]]
@@ -385,6 +389,8 @@ void t8(void) {
// CIR-NEXT: in_out = [%[[A_LOAD]] : !u32i],
// CIR-NEXT: {"bswap $0 $1" "=r,0,~{dirflag},~{fpsr},~{flags}"}) -> !u32i
// LLVM: define{{.*}}@t9
+// Classic codegen doesn't alloca for a return slot.
+// CIRLLVMONLY: alloca i32
// LLVM: %[[A_ADDR:.*]] = alloca i32
// LLVM: %[[A:.*]] = load i32, ptr %[[A_ADDR]]
// LLVM: call i32 asm "bswap $0 $1", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %[[A]])
@@ -427,9 +433,9 @@ void t10(int r) {
// CIR-NEXT: {"xyz" "={ax},0,~{dirflag},~{fpsr},~{flags}"}) -> !u32i
// CIR-NEXT: cir.store align(4) %[[ASM_RES]], %[[OUTPUT]] : !u32i, !cir.ptr<!u32i>
// LLVM: define{{.*}}@t11
-// LLVM: %[[INPUT:.*]] = alloca i8
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca i32
+// LLVM: %[[INPUT:.*]] = alloca i8
// LLVM: %[[OUTPUT:.*]] = alloca i32
// LLVM: %[[INPUT_LOAD:.*]] = load i8, ptr %[[INPUT]]
// The two IR forms disagree as to whether this should be a zero or sign extend.
@@ -459,9 +465,9 @@ unsigned t11(signed char input) {
// CIR-NEXT: %[[ASM_RES_INT:.*]] = cir.cast integral %[[ASM_RES]] : !u32i -> !u8i
// CIR-NEXT: cir.store align(1) %[[ASM_RES_INT]], %[[OUTPUT]] : !u8i, !cir.ptr<!u8i>
// LLVM: define{{.*}}@t12
-// LLVM: %[[INPUT:.*]] = alloca i32
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca i8
+// LLVM: %[[INPUT:.*]] = alloca i32
// LLVM: %[[OUTPUT:.*]] = alloca i8
// LLVM: %[[INPUT_LOAD:.*]] = load i32, ptr %[[INPUT]]
// LLVM: %[[ASM_RES:.*]] = call i32 asm "xyz", "={ax},0,~{dirflag},~{fpsr},~{flags}"(i32 %[[INPUT_LOAD]])
@@ -487,9 +493,9 @@ unsigned char t12(unsigned input) {
// CIR-NEXT: %[[ASM_RES_INT:.*]] = cir.cast integral %[[ASM_RES]] : !u32i -> !u8i
// CIR-NEXT: cir.store align(1) %[[ASM_RES_INT]], %[[OUTPUT]] : !u8i, !cir.ptr<!u8i>
// LLVM: define{{.*}}@t13
-// LLVM: %[[INPUT:.*]] = alloca i32
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca i8
+// LLVM: %[[INPUT:.*]] = alloca i32
// LLVM: %[[OUTPUT:.*]] = alloca i8
// LLVM: %[[INPUT_LOAD:.*]] = load i32, ptr %[[INPUT]]
// LLVM: %[[ASM_RES:.*]] = call i32 asm "xyz $1", "={ax},0,~{dirflag},~{fpsr},~{flags}"(i32 %[[INPUT_LOAD]])
@@ -527,8 +533,8 @@ struct large {
// CIR: cir.func{{.*}}@t15
// 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: %[[LARGE_LOAD:.*]] = cir.load deref align(8) %[[LARGE]] : !cir.ptr<!cir.ptr<!rec_large>>, !cir.ptr<!rec_large>
+// CIR: %[[X_LOAD:.*]] = cir.load align(4) %[[X]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [%[[LARGE_LOAD]] : !cir.ptr<!rec_large> (maybe_memory), %[[X_LOAD]] : !s32i],
@@ -610,9 +616,9 @@ void t17(void) {
// CIR-NEXT: cir.store align(4) %[[GM_FIRST_LOAD]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store align(4) %[[GM_SEC_LOAD]], %[[B]] : !s32i, !cir.ptr<!s32i>
// LLVM: define{{.*}}@t18
-// LLVM: %[[DATA:.*]] = alloca i32
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca i32
+// LLVM: %[[DATA:.*]] = alloca i32
// LLVM: %[[A:.*]] = alloca i32
// LLVM: %[[B:.*]] = alloca i32
//
@@ -653,9 +659,9 @@ int t18(unsigned data) {
// CIR-NEXT: {"x$(abc$|def$|ghi$)z" "=r,r,~{dirflag},~{fpsr},~{flags}"}) -> !s32i
// CIR-NEXT: cir.store align(4) %[[ASM_RES]], %[[A]] : !s32i, !cir.ptr<!s32i>
// LLVM: define{{.*}}@t19
-// LLVM: %[[DATA:.*]] = alloca i32
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca i32
+// LLVM: %[[DATA:.*]] = alloca i32
// LLVM: %[[A:.*]] = alloca i32
// LLVM: %[[B:.*]] = alloca i32
// LLVM: %[[DATA_LOAD:.*]] = load i32, ptr %[[DATA]]
@@ -745,9 +751,9 @@ unsigned char t23(unsigned char a, unsigned char b) {
// CIR-NEXT: {"foobar" "={ax},0,~{dirflag},~{fpsr},~{flags}"}) -> !cir.ptr<!void>
// CIR-NEXT: cir.store align(8) %[[ASM_RES]], %[[ADDR]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// LLVM: define{{.*}}@t24
-// LLVM: %[[C:.*]] = alloca i8
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca ptr
+// LLVM: %[[C:.*]] = alloca i8
// LLVM: %[[ADDR:.*]] = alloca ptr
// LLVM: %[[C_LOAD:.*]] = load i8, ptr %[[C]]
// The two IR forms disagree as to whether this should be a zero or sign extend.
@@ -871,7 +877,7 @@ void t31(int len) {
// CIR: cir.func{{.*}}@t33
// 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: %[[PTR_LOAD:.*]] = cir.load align(8) %[[PTR]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[ASM_RES:.*]] = cir.asm(x86_att,
// CIR-NEXT: out = [],
// CIR-NEXT: in = [%[[PTR_LOAD]] : !cir.ptr<!void>],
@@ -879,9 +885,9 @@ void t31(int len) {
// CIR-NEXT: {"lea $1, $0" "=r,p,~{dirflag},~{fpsr},~{flags}"}) -> !cir.ptr<!void>
// CIR-NEXT: cir.store align(8) %[[ASM_RES]], %[[RET]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// LLVM: define{{.*}}@t33
-// LLVM: %[[PTR:.*]] = alloca ptr
// Classic codegen doesn't alloca for a return slot.
// CIRLLVMONLY: alloca ptr
+// LLVM: %[[PTR:.*]] = alloca ptr
// LLVM: %[[RET:.*]] = alloca ptr
// LLVM: %[[PTR_LOAD:.*]] = load ptr, ptr %[[PTR]]
// LLVM: %[[ASM_RES:.*]] = call ptr asm "lea $1, $0", "=r,p,~{dirflag},~{fpsr},~{flags}"(ptr %[[PTR_LOAD]])
diff --git a/clang/test/CIR/CodeGen/inline-cxx-func.cpp b/clang/test/CIR/CodeGen/inline-cxx-func.cpp
index e5866a28914e92..fb5c746f543fca 100644
--- a/clang/test/CIR/CodeGen/inline-cxx-func.cpp
+++ b/clang/test/CIR/CodeGen/inline-cxx-func.cpp
@@ -28,8 +28,8 @@ void use() {
// CIR: cir.return
// CIR: cir.func{{.*}} @_ZN1S10InlineFuncEv(%arg0: !cir.ptr<!rec_S> {{.*}}) -> (!s32i {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_S>>
// 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>
@@ -44,8 +44,8 @@ void use() {
// LLVM: ret void
// LLVM: define{{.*}} i32 @_ZN1S10InlineFuncEv(ptr{{.*}} %[[ARG0:.*]])
-// LLVM: %[[THIS_ADDR:.*]] = alloca ptr, align 8
// LLVM: %[[RET_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[THIS_ADDR:.*]] = alloca ptr, align 8
// LLVM: store ptr %[[ARG0]], ptr %[[THIS_ADDR]], align 8
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ADDR]], align 8
// LLVM: %[[MEMBER_ADDR:.*]] = getelementptr inbounds nuw %struct.S, ptr %[[THIS]], i32 0, i32 0
diff --git a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
index deb09ba9710b38..271da749e12ae3 100644
--- a/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
+++ b/clang/test/CIR/CodeGen/lambda-static-invoker.cpp
@@ -39,8 +39,8 @@ int g3() {
// lambda operator int (*)(int const&)()
// CIR: cir.func no_inline alignment(2) 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<!cir.ptr<![[REC_LAM_G3]]>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !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: 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>>
@@ -67,8 +67,8 @@ int g3() {
// lambda operator int (*)(int const&)()
// LLVM: define internal {{.*}}ptr @"_ZZ2g3vENK3$_0cvPFiRKiEEv"(ptr {{.*}} %[[THIS_ARG:.*]]){{.*}} {
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca ptr
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
// LLVM: store ptr @"_ZZ2g3vEN3$_08__invokeERKi", ptr %[[RETVAL]]
@@ -110,8 +110,8 @@ void use_void_lambda() {
// lambda operator void (*)(int)()
// CIR: cir.func no_inline alignment(2) 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<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!cir.func<(!s32i)>>>
+// CIR: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_VOID_LAMBDA]]>>
// 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)>>
@@ -121,8 +121,8 @@ void use_void_lambda() {
// lambda invoker
// CIR: cir.func no_inline alignment(2) 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: %[[REF_I_ALLOCA:.*]] = cir.alloca "i" {{.*}} init const
// 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]]
@@ -133,9 +133,9 @@ void use_void_lambda() {
// lambda operator()
// CIR: cir.func no_inline lambda alignment(2) internal private dso_local @_ZZ2g3vENK3$_0clERKi(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_G3]]> {{.*}}, %[[REF_I_ARG:.*]]: !cir.ptr<!s32i> {{.*}})
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval"
// 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]]
// CIR: cir.store %[[REF_I_ARG]], %[[REF_I_ALLOCA]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA]]
@@ -172,8 +172,8 @@ void use_void_lambda() {
// lambda operator void (*)(int)()
// LLVM: define internal noundef ptr @"_ZZ15use_void_lambdavENK3$_0cvPFDaT_EIiEEv"(ptr {{.*}} %[[THIS_ARG:.*]])
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca ptr
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
// LLVM: store ptr @"_ZZ15use_void_lambdavEN3$_08__invokeIiEEDaT_", ptr %[[RETVAL]]
@@ -182,8 +182,8 @@ void use_void_lambda() {
// lambda invoker
// LLVM: define internal {{.*}}i32 @"_ZZ2g3vEN3$_08__invokeERKi"(ptr {{.*}} %[[REF_I_ARG:.*]]){{.*}} {
-// LLVM: %[[REF_I_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[REF_I_ALLOCA:.*]] = alloca ptr
// LLVM: %[[LAM_ALLOCA:.*]] = alloca %[[REC_LAM_G3]],
// LLVM: store ptr %[[REF_I_ARG]], ptr %[[REF_I_ALLOCA]]
// LLVM: %[[REF_I:.*]] = load ptr, ptr %[[REF_I_ALLOCA]]
@@ -194,9 +194,9 @@ void use_void_lambda() {
// lambda operator()
// LLVM: define internal {{.*}}i32 @"_ZZ2g3vENK3$_0clERKi"(ptr {{.*}} %[[THIS_ARG:.*]], ptr {{.*}} %[[REF_I_ARG:.*]]){{.*}} {
+// LLVM: %[[RETVAL:.*]] = alloca i32
// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[REF_I_ALLOCA:.*]] = alloca ptr
-// LLVM: %[[RETVAL:.*]] = alloca i32
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: store ptr %[[REF_I_ARG]], ptr %[[REF_I_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp
index cf5d2be4dbb24d..86b9ce87bb10cf 100644
--- a/clang/test/CIR/CodeGen/lambda.cpp
+++ b/clang/test/CIR/CodeGen/lambda.cpp
@@ -246,8 +246,8 @@ int f() {
// CIR: cir.return %[[RET]]
// CIR:cir.func {{.*}} lambda alignment(2) 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<!cir.ptr<![[REC_LAM_G2]]>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_G2]]>>
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
// CIR: %[[ONE_HUNDRED:.*]] = cir.const #cir.int<100> : !s32i
@@ -277,8 +277,8 @@ int f() {
// LLVM: ret i32 %[[RET]]
// LLVM: define internal noundef i32 @"_ZZ2g2vENK3$_0clEv"(ptr {{.*}} %[[THIS_ARG:.*]])
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[I_ALLOCA:.*]] = alloca i32
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
// LLVM: %[[I_ADDR_ADDR:.*]] = getelementptr inbounds nuw %[[REC_LAM_G2]], ptr %[[THIS]], i32 0, i32 0
@@ -340,8 +340,8 @@ 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<!cir.ptr<!rec_A>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_A>>
// 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>
@@ -353,8 +353,8 @@ struct A {
// CIR: cir.return %[[RET]]
// LLVM: define linkonce_odr noundef i32 @_ZN1A3fooEv(ptr {{.*}} %[[THIS_ARG:.*]])
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[LAM_ALLOCA:.*]] = alloca %[[REC_LAM_A:[^,]*]],
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
@@ -377,8 +377,8 @@ 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<!cir.ptr<!rec_A>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!rec_A>>
// 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>
@@ -390,8 +390,8 @@ struct A {
// CIR: cir.return %[[RET]]
// LLVM: define linkonce_odr noundef i32 @_ZN1A3barEv(ptr {{.*}} %[[THIS_ARG:.*]])
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[LAM_ALLOCA:.*]] = alloca %[[REC_LAM_PTR_A:[^,]*]],
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
@@ -414,8 +414,8 @@ struct A {
// lambda operator() in foo()
// CIR: cir.func {{.*}} lambda comdat alignment(2) linkonce_odr @_ZZN1A3fooEvENKUlvE_clEv(%[[THIS_ARG:.*]]: !cir.ptr<![[REC_LAM_A]]> {{.*}})
-// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_A]]>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_A]]>>
// CIR: cir.store{{.*}} %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
// CIR: %[[STRUCT_A:.*]] = cir.get_member %[[THIS]][0] {name = "this"}
@@ -426,8 +426,8 @@ struct A {
// CIR: cir.return %[[RET]]
// LLVM: define linkonce_odr {{.*}}i32 @_ZZN1A3fooEvENKUlvE_clEv(ptr {{.*}} %[[THIS_ARG:.*]])
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
// LLVM: %[[PTR_A:.*]] = getelementptr inbounds nuw %[[REC_LAM_A]], ptr %[[THIS]], i32 0, i32 0
@@ -448,8 +448,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<!cir.ptr<![[REC_LAM_PTR_A]]>>
// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[THIS_ADDR:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<![[REC_LAM_PTR_A]]>>
// 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"}
@@ -461,8 +461,8 @@ struct A {
// CIR: cir.return %[[RET]]
// LLVM: define linkonce_odr noundef i32 @_ZZN1A3barEvENKUlvE_clEv(ptr {{.*}} %[[THIS_ARG:.*]])
-// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
// LLVM: store ptr %[[THIS_ARG]], ptr %[[THIS_ALLOCA]]
// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
// LLVM: %[[STRUCT_A_ADDRR_ADDR:.*]] = getelementptr inbounds nuw %[[REC_LAM_PTR_A]], ptr %[[THIS]], i32 0, i32 0
diff --git a/clang/test/CIR/CodeGen/launder.cpp b/clang/test/CIR/CodeGen/launder.cpp
index f0f69d678c8569..c665944e516ad7 100644
--- a/clang/test/CIR/CodeGen/launder.cpp
+++ b/clang/test/CIR/CodeGen/launder.cpp
@@ -27,16 +27,16 @@ auto use_derived(Derived *d) {
return __builtin_launder(d);
}
// CIR-LABEL: cir.func{{.*}}@_Z11use_derivedP7Derived
-// 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_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !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>
// CIR: cir.return %[[RET]] : !cir.ptr<!rec_Derived>
//
// LLVM-LABEL: define {{.*}}@_Z11use_derivedP7Derived
-// LLVM: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RET_ALLOCA:.*]] = alloca ptr
+// LLVM: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG_ALLOCA]]
// LLVM: store ptr %[[ARG_LOAD]], ptr %[[RET_ALLOCA]]
// LLVM: %[[RET:.*]] = load ptr, ptr %[[RET_ALLOCA]]
@@ -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<!cir.ptr<!rec_Derived>>
// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_Derived>>
+// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !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>>
@@ -57,8 +57,8 @@ auto use_derived(Derived *d) {
// CIR-STRICT: cir.return %[[RET]] : !cir.ptr<!rec_Derived>
//
// LLVM-STRICT-LABEL: define {{.*}}@_Z11use_derivedP7Derived
-// LLVM-STRICT: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM-STRICT: %[[RET_ALLOCA:.*]] = alloca ptr
+// LLVM-STRICT: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM-STRICT: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG_ALLOCA]]
// LLVM-STRICT: %[[LAUNDER:.*]] = call ptr @llvm.launder.invariant.group.p0(ptr %[[ARG_LOAD]])
// LLVM-STRICT: store ptr %[[LAUNDER]], ptr %[[RET_ALLOCA]]
@@ -76,15 +76,15 @@ auto use_vm(VirtMem *vm) {
return __builtin_launder(vm);
}
// CIR-LABEL: cir.func {{.*}}@_Z6use_vmP7VirtMem
-// 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: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init : !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>
//
// LLVM-LABEL: define {{.*}}@_Z6use_vmP7VirtMem
-// LLVM: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RET_ALLOCA:.*]] = alloca ptr
+// LLVM: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG_ALLOCA]]
// LLVM: store ptr %[[ARG_LOAD]], ptr %[[RET_ALLOCA]]
// LLVM: %[[RET:.*]] = load ptr, ptr %[[RET_ALLOCA]]
@@ -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<!cir.ptr<!rec_VirtMem>>
// CIR-STRICT: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!rec_VirtMem>>
+// CIR-STRICT: %[[ARG_ALLOCA:.*]] = cir.alloca "vm" {{.*}} init : !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>>
@@ -105,8 +105,8 @@ auto use_vm(VirtMem *vm) {
// CIR-STRICT: cir.return %[[RET]] : !cir.ptr<!rec_VirtMem>
//
// LLVM-STRICT-LABEL: define {{.*}}@_Z6use_vmP7VirtMem
-// LLVM-STRICT: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM-STRICT: %[[RET_ALLOCA:.*]] = alloca ptr
+// LLVM-STRICT: %[[ARG_ALLOCA:.*]] = alloca ptr
// LLVM-STRICT: %[[ARG_LOAD:.*]] = load ptr, ptr %[[ARG_ALLOCA]]
// LLVM-STRICT: %[[LAUNDER:.*]] = call ptr @llvm.launder.invariant.group.p0(ptr %[[ARG_LOAD]])
// LLVM-STRICT: store ptr %[[LAUNDER]], ptr %[[RET_ALLOCA]]
diff --git a/clang/test/CIR/CodeGen/lifetime-marker.cpp b/clang/test/CIR/CodeGen/lifetime-marker.cpp
index 12ac98b3d53437..4100e98d093367 100644
--- a/clang/test/CIR/CodeGen/lifetime-marker.cpp
+++ b/clang/test/CIR/CodeGen/lifetime-marker.cpp
@@ -125,6 +125,7 @@ void if_body(int n) {
// CIR: cir.call @_Z3usei
// LLVM-LABEL: define{{.*}} void @_Z7if_bodyi
+// LLVM: %[[N:.*]] = alloca i32
// LLVM: %[[X:.*]] = alloca i32
// LLVM: br i1 %{{.*}}, label %[[IF_BODY:[0-9]+]], label %[[IF_END:[0-9]+]]
// LLVM: [[IF_BODY]]:
diff --git a/clang/test/CIR/CodeGen/long-double-inc-dec.cpp b/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
index 4321a63c0fbc98..a2e14064952355 100644
--- a/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
+++ b/clang/test/CIR/CodeGen/long-double-inc-dec.cpp
@@ -21,12 +21,12 @@
extern "C" long double do_pre_inc(long double d) {
// CIR-LABEL: @do_pre_inc(
- // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
// CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_pre_inc(
- // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
// LLVMCIR: %[[RET_ALLOCA:.*]] = alloca [[LDTY]]
+ // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
return ++d;
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG_ALLOCA]] : !cir.ptr<!cir.long_double<![[LDTY]]>>, !cir.long_double<![[LDTY]]>
@@ -47,12 +47,12 @@ 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.ptr<!cir.long_double<![[LDTY]]>>
// CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_post_inc(
- // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
// LLVMCIR: %[[RET_ALLOCA:.*]] = alloca [[LDTY]]
+ // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
return d++;
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG_ALLOCA]] : !cir.ptr<!cir.long_double<![[LDTY]]>>, !cir.long_double<![[LDTY]]>
@@ -74,12 +74,12 @@ 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.ptr<!cir.long_double<![[LDTY]]>>
// CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_pre_dec(
- // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
// LLVMCIR: %[[RET_ALLOCA:.*]] = alloca [[LDTY]]
+ // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
return --d;
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG_ALLOCA]] : !cir.ptr<!cir.long_double<![[LDTY]]>>, !cir.long_double<![[LDTY]]>
@@ -101,12 +101,12 @@ 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.ptr<!cir.long_double<![[LDTY]]>>
// CIR: %[[RET_ALLOCA:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.long_double<![[LDTY]]>>
+ // CIR: %[[ARG_ALLOCA:.*]] = cir.alloca "d" {{.*}} init : !cir.ptr<!cir.long_double<![[LDTY]]>>
//
// LLVM-LABEL: @do_post_dec(
- // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
// LLVMCIR: %[[RET_ALLOCA:.*]] = alloca [[LDTY]]
+ // LLVM: %[[ARG_ALLOCA:.*]] = alloca [[LDTY]]
return d--;
// CIR: %[[ARG_LOAD:.*]] = cir.load {{.*}}%[[ARG_ALLOCA]] : !cir.ptr<!cir.long_double<![[LDTY]]>>, !cir.long_double<![[LDTY]]>
diff --git a/clang/test/CIR/CodeGen/loop-cond-var-cleanup.cpp b/clang/test/CIR/CodeGen/loop-cond-var-cleanup.cpp
index 548047879421ff..765996cee4dc44 100644
--- a/clang/test/CIR/CodeGen/loop-cond-var-cleanup.cpp
+++ b/clang/test/CIR/CodeGen/loop-cond-var-cleanup.cpp
@@ -41,8 +41,8 @@ void while_cond_var(int n) {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z14while_cond_vari(i32 %0) {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// The loop header branches into the condition region or to the loop exit.
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
@@ -161,8 +161,8 @@ void while_cond_var_break() {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z20while_cond_var_breakv() {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
// LLVM: [[COND]]:
@@ -262,8 +262,8 @@ void while_cond_var_continue() {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z23while_cond_var_continuev() {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
// LLVM: [[COND]]:
@@ -369,8 +369,8 @@ void for_cond_var_break() {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z18for_cond_var_breakv() {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
// LLVM: [[COND]]:
@@ -471,8 +471,8 @@ void for_cond_var_continue() {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z21for_cond_var_continuev() {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
// LLVM: [[COND]]:
@@ -585,8 +585,8 @@ void for_cond_var(int n) {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z12for_cond_vari(i32 %0) {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
// LLVM: [[COND]]:
@@ -710,9 +710,9 @@ void while_cond_var_temp(int n) {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z19while_cond_var_tempi(i32 %0) {{.*}} personality ptr @__gxx_personality_v0 {
+// LLVM: %[[FLAG:.*]] = alloca i8
// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[TMP:.*]] = alloca %struct.S
-// LLVM: %[[FLAG:.*]] = alloca i8
// LLVM: br label %{{.*}}
// LLVM: br label %[[COND:.*]]
// LLVM: [[COND]]:
@@ -866,9 +866,9 @@ void while_cond_var_nested(int n) {
// CIR: }
// LLVM-LABEL: define dso_local void @_Z21while_cond_var_nestedi(i32 %0) {{.*}} personality ptr @__gxx_personality_v0 {
-// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: %[[FLAG_OUTER:.*]] = alloca i8
// LLVM: %[[FLAG_INNER:.*]] = alloca i8
+// LLVM: %[[S:.*]] = alloca %struct.S
// LLVM: br label %{{.*}}
// LLVM: br label %[[OUTER_COND:.*]]
// LLVM: [[OUTER_COND]]:
diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp
index f6f2ea7af0c12c..15525220be67f8 100644
--- a/clang/test/CIR/CodeGen/loop.cpp
+++ b/clang/test/CIR/CodeGen/loop.cpp
@@ -235,11 +235,11 @@ void l4() {
// CIR: }
// LLVM: define{{.*}} void @_Z2l4v(){{.*}} {
+// LLVM: %[[A_ADDR:.*]] = alloca [10 x i32]
// LLVM: %[[RANGE_ADDR:.*]] = alloca ptr
// LLVM: %[[BEGIN_ADDR:.*]] = alloca ptr
// LLVM: %[[END_ADDR:.*]] = alloca ptr
// LLVM: %[[N_ADDR:.*]] = alloca i32
-// LLVM: %[[A_ADDR:.*]] = alloca [10 x i32]
// LLVM: br label %[[SETUP:.*]]
// LLVM: [[SETUP]]:
// LLVM: store ptr %[[A_ADDR]], ptr %[[RANGE_ADDR]]
diff --git a/clang/test/CIR/CodeGen/pack-indexing.cpp b/clang/test/CIR/CodeGen/pack-indexing.cpp
index 86b63c004f06f8..48bad5864f85ac 100644
--- a/clang/test/CIR/CodeGen/pack-indexing.cpp
+++ b/clang/test/CIR/CodeGen/pack-indexing.cpp
@@ -21,10 +21,10 @@ int pack_indexing_scalar() { return pack_indexing(1, 2, 3); }
// CIR: %[[TMP:.*]] = cir.load %[[RET_VAL]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.return %[[TMP]] : !s32i
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !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
@@ -36,10 +36,10 @@ int pack_indexing_scalar() { return pack_indexing(1, 2, 3); }
// LLVM: %[[TMP:.*]] = load i32, ptr %[[RET_VAL]], align 4
// LLVM: ret i32 %[[TMP]]
+// LLVM: %[[RET_VAL:.*]] = alloca i32, align 4
// LLVM: %[[P_0:.*]] = alloca i32, align 4
// LLVM: %[[P_1:.*]] = alloca i32, align 4
// LLVM: %[[P_2:.*]] = alloca i32, align 4
-// LLVM: %[[RET_VAL:.*]] = alloca i32, align 4
// LLVM: %[[RESULT:.*]] = load i32, ptr %[[P_0]], align 4
// LLVM: store i32 %[[RESULT]], ptr %[[RET_VAL]], align 4
// LLVM: %[[TMP:.*]] = load i32, ptr %[[RET_VAL]], align 4
@@ -147,8 +147,8 @@ void pack_indexing_lvalue() {
// CIR: cir.return
// CIR: cir.func {{.*}} @_Z27pack_indexing_lvalue_helperIJiEERDaDpRT_(%[[ARG0:.*]]: !cir.ptr<!s32i> {{.*}}) -> (!cir.ptr<!s32i> {{.*}})
-// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: cir.store %[[ARG0]], %[[P_ADDR]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[P_LOAD:.*]] = cir.load %[[P_ADDR]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
// CIR: cir.store %[[P_LOAD]], %[[RET_VAL]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
@@ -164,8 +164,8 @@ void pack_indexing_lvalue() {
// LLVM: ret void
// LLVM: define {{.*}} ptr @_Z27pack_indexing_lvalue_helperIJiEERDaDpRT_(ptr {{.*}} %[[ARG0:.*]])
-// LLVM: %[[P_ADDR:.*]] = alloca ptr, align 8
// LLVM: %[[RET_VAL:.*]] = alloca ptr, align 8
+// LLVM: %[[P_ADDR:.*]] = alloca ptr, align 8
// LLVM: store ptr %[[ARG0]], ptr %[[P_ADDR]], align 8
// LLVM: %[[P_LOAD:.*]] = load ptr, ptr %[[P_ADDR]], align 8
// LLVM: store ptr %[[P_LOAD]], ptr %[[RET_VAL]], align 8
@@ -201,9 +201,9 @@ Agg pack_indexing_aggregate() {
// CIR: cir.call @_Z13pack_indexingIJ3AggS0_EEDaDpT_
// CIR: cir.func {{.*}} @_Z13pack_indexingIJ3AggS0_EEDaDpT_
+// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Agg>
// CIR: %[[P0:.*]] = cir.alloca "p" {{.*}} : !cir.ptr<!rec_Agg>
// CIR: %[[P1:.*]] = cir.alloca "p" {{.*}} : !cir.ptr<!rec_Agg>
-// CIR: %[[RET_VAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Agg>
// CIR: cir.copy %[[P0]] {{.*}} to %[[RET_VAL]] {{.*}} : !cir.ptr<!rec_Agg>
// LLVM: define {{.*}} i64 @_Z23pack_indexing_aggregatev()
diff --git a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
index 7561deece14fc1..328fae6b5de000 100644
--- a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
+++ b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
@@ -258,19 +258,16 @@ U foo5() {
// LLVM: define dso_local { i64, double } @{{.*foo6.*}}(i8 %{{.+}}, double %{{.+}})
-// LLVMCIR: [[A:%.*]] = alloca [[STRUCT_A]], align 8
-// LLVMCIR-NEXT: [[RETVAL:%.*]] = alloca [[UNION_U]], align 8
-// LLVMCIR: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[RETVAL]], ptr align 8 [[A]], i64 16, i1 false)
+// LLVM: [[RETVAL:%.*]] = alloca [[UNION_U]], align 8
+// LLVM-NEXT: [[A:%.*]] = alloca [[STRUCT_A]], align 8
+// LLVM: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[RETVAL]], ptr align 8 [[A]], i64 16, i1 false)
// LLVMCIR-NEXT: [[TMP_0:%.*]] = load { i64, double }, ptr [[RETVAL]], align 8
-// OGCG: [[RETVAL:%.*]] = alloca [[UNION_U]], align 8
-// OGCG-NEXT: [[A:%.*]] = alloca [[STRUCT_A]], align 8
-// OGCG: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[RETVAL]], ptr align 8 [[A]], i64 16, i1 false)
// OGCG-NEXT: [[DIVE:%.*]] = getelementptr inbounds nuw [[UNION_U]], ptr [[RETVAL]], i32 0, i32 0
// OGCG-NEXT: [[TMP_0:%.*]] = load { i64, double }, ptr [[DIVE]], align 8
// LLVM-NEXT: ret { i64, double } [[TMP_0]]
// CIR-LABEL: cir.func no_inline dso_local @_Z4foo61A(
-// 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: %[[A_ALLOCA:.*]] = cir.alloca "a" align(8) init : !cir.ptr<![[STRUCT_A]]>
// CIR: %[[GET_A:.*]] = cir.get_member %[[RET_ALLOCA:.*]][1] {name = "a"} : !cir.ptr<![[UNION_U]]> -> !cir.ptr<![[STRUCT_A]]>
// CIR: cir.copy %[[A_ALLOCA]] align(8) to %[[GET_A:.*]] align(8) : !cir.ptr<![[STRUCT_A]]>
U foo6(A 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 ac4cf4e63b9543..b7d2acd6ddab0e 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member-cast.cpp
@@ -89,8 +89,8 @@ auto base_to_derived_zero_offset(int Base1::*ptr) -> int Derived::* {
// No LLVM instructions emitted for performing a zero-offset cast.
// LLVM: define {{.*}} i64 @_Z27base_to_derived_zero_offsetM5Base1i
-// LLVM-NEXT: %[[PTR_ADDR:.*]] = alloca i64
// LLVM-NEXT: %[[RETVAL:.*]] = alloca i64
+// LLVM-NEXT: %[[PTR_ADDR:.*]] = alloca i64
// LLVM-NEXT: store i64 %{{.*}}, ptr %[[PTR_ADDR]]
// LLVM-NEXT: %[[TEMP:.*]] = load i64, ptr %[[PTR_ADDR]]
// LLVM-NEXT: store i64 %[[TEMP]], ptr %[[RETVAL]]
@@ -119,8 +119,8 @@ auto derived_to_base_zero_offset(int Derived::*ptr) -> int Base1::* {
// No LLVM instructions emitted for performing a zero-offset cast.
// LLVM: define {{.*}} i64 @_Z27derived_to_base_zero_offsetM7Derivedi
-// LLVM-NEXT: %[[PTR_ADDR:.*]] = alloca i64
// LLVM-NEXT: %[[RETVAL:.*]] = alloca i64
+// LLVM-NEXT: %[[PTR_ADDR:.*]] = alloca i64
// LLVM-NEXT: store i64 %{{.*}}, ptr %[[PTR_ADDR]]
// LLVM-NEXT: %[[TEMP:.*]] = load i64, ptr %[[PTR_ADDR]]
// LLVM-NEXT: store i64 %[[TEMP]], ptr %[[RETVAL]]
@@ -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 : !cir.ptr<!s64i>
// CIR-AFTER: %[[RET_ADDR:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!s64i>
+// CIR-AFTER: %[[X_ADDR:.*]] = cir.alloca "x" align(8) init : !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 f8e06fdf69a2da..69519e072a629d 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
@@ -146,9 +146,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: %[[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]]
@@ -162,9 +162,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: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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>
@@ -178,9 +178,9 @@ int test2(const Point &pt, int Point::*member) {
// CIR-AFTER: cir.return %[[RET]] : !s32i
// LLVM: define {{.*}} i32 @_Z5test2RK5PointMS_i(ptr {{.*}} %[[PT_ARG:.*]], i64 %[[MEMBER_ARG:.*]])
+// LLVM: %[[RETVAL_ADDR:.*]] = alloca i32
// LLVM: %[[PT_ADDR:.*]] = alloca ptr
// LLVM: %[[MEMBER_ADDR:.*]] = alloca i64
-// LLVM: %[[RETVAL_ADDR:.*]] = alloca i32
// LLVM: store ptr %[[PT_ARG]], ptr %[[PT_ADDR]]
// LLVM: store i64 %[[MEMBER_ARG]], ptr %[[MEMBER_ADDR]]
// LLVM: %[[PT:.*]] = load ptr, ptr %[[PT_ADDR]]
@@ -209,9 +209,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: %[[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]]
@@ -225,9 +225,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: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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>
@@ -241,9 +241,9 @@ int test3(const Point *pt, int Point::*member) {
// CIR-AFTER: cir.return %[[RET]] : !s32i
// LLVM: define {{.*}} i32 @_Z5test3PK5PointMS_i(ptr {{.*}} %[[PT_ARG:.*]], i64 %[[MEMBER_ARG:.*]])
+// LLVM: %[[RETVAL_ADDR:.*]] = alloca i32
// LLVM: %[[PT_ADDR:.*]] = alloca ptr
// LLVM: %[[MEMBER_ADDR:.*]] = alloca i64
-// LLVM: %[[RETVAL_ADDR:.*]] = alloca i32
// LLVM: store ptr %[[PT_ARG]], ptr %[[PT_ADDR]]
// LLVM: store i64 %[[MEMBER_ARG]], ptr %[[MEMBER_ADDR]]
// LLVM: %[[PT:.*]] = load ptr, ptr %[[PT_ADDR]]
@@ -273,8 +273,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: cir.store %[[MEMBER_ARG]], %[[MEMBER_ADDR]]
// CIR-BEFORE: %[[MEMBER:.*]] = cir.load{{.*}} %[[MEMBER_ADDR]]
// CIR-BEFORE: cir.store %[[MEMBER]], %[[RETVAL_ADDR]]
@@ -283,8 +283,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 : !cir.ptr<!s64i>
// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s64i>
+// CIR-AFTER: %[[MEMBER_ADDR:.*]] = cir.alloca "member" {{.*}} init : !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>
@@ -292,8 +292,8 @@ auto test4(int Incomplete::*member) -> int Incomplete::* {
// CIR-AFTER: cir.return %[[RET]] : !s64i
// LLVM: define {{.*}} i64 @_Z5test4M10Incompletei(i64 %[[MEMBER_ARG:.*]])
-// LLVM: %[[MEMBER_ADDR:.*]] = alloca i64
// LLVM: %[[RETVAL_ADDR:.*]] = alloca i64
+// LLVM: %[[MEMBER_ADDR:.*]] = alloca i64
// LLVM: store i64 %[[MEMBER_ARG]], ptr %[[MEMBER_ADDR]]
// LLVM: %[[MEMBER:.*]] = load i64, ptr %[[MEMBER_ADDR]]
// LLVM: store i64 %[[MEMBER]], ptr %[[RETVAL_ADDR]]
@@ -313,9 +313,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: %[[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]]
@@ -329,9 +329,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: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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>
@@ -345,9 +345,9 @@ int test5(Incomplete *ic, int Incomplete::*member) {
// CIR-AFTER: cir.return %[[RET]] : !s32i
// LLVM: define {{.*}} i32 @_Z5test5P10IncompleteMS_i(ptr {{.*}} %[[IC_ARG:.*]], i64 %[[MEMBER_ARG:.*]])
+// LLVM: %[[RETVAL_ADDR:.*]] = alloca i32
// LLVM: %[[IC_ADDR:.*]] = alloca ptr
// LLVM: %[[MEMBER_ADDR:.*]] = alloca i64
-// LLVM: %[[RETVAL_ADDR:.*]] = alloca i32
// LLVM: store ptr %[[IC_ARG]], ptr %[[IC_ADDR]]
// LLVM: store i64 %[[MEMBER_ARG]], ptr %[[MEMBER_ADDR]]
// LLVM: %[[IC:.*]] = load ptr, ptr %[[IC_ADDR]]
@@ -497,9 +497,9 @@ Inner test_agg_dot(const Outer &o, Inner Outer::*p) {
// CIR-BEFORE-LABEL: cir.func {{.*}} @_Z12test_agg_dotRK5OuterMS_5Inner(
// CIR-BEFORE-SAME: %[[O_ARG:.*]]: !cir.ptr<!rec_Outer>
// CIR-BEFORE-SAME: %[[P_ARG:.*]]: !cir.data_member<!rec_Inner in !rec_Outer>
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-BEFORE: %[[O_ADDR:.*]] = cir.alloca "o" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Outer>>
// CIR-BEFORE: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.data_member<!rec_Inner in !rec_Outer>>
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-BEFORE: cir.store %[[O_ARG]], %[[O_ADDR]]
// CIR-BEFORE: cir.store %[[P_ARG]], %[[P_ADDR]]
// CIR-BEFORE: %[[O:.*]] = cir.load %[[O_ADDR]]
@@ -511,9 +511,9 @@ Inner test_agg_dot(const Outer &o, Inner Outer::*p) {
// CIR-AFTER-LABEL: cir.func {{.*}} @_Z12test_agg_dotRK5OuterMS_5Inner(
// CIR-AFTER-SAME: %[[O_ARG:.*]]: !cir.ptr<!rec_Outer>
// CIR-AFTER-SAME: %[[P_ARG:.*]]: !s64i
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-AFTER: %[[O_ADDR:.*]] = cir.alloca "o" {{.*}} init const : !cir.ptr<!cir.ptr<!rec_Outer>>
// CIR-AFTER: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!s64i>
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-AFTER: cir.store %[[O_ARG]], %[[O_ADDR]] : !cir.ptr<!rec_Outer>, !cir.ptr<!cir.ptr<!rec_Outer>>
// CIR-AFTER: cir.store %[[P_ARG]], %[[P_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[O:.*]] = cir.load %[[O_ADDR]] : !cir.ptr<!cir.ptr<!rec_Outer>>, !cir.ptr<!rec_Outer>
@@ -525,9 +525,9 @@ Inner test_agg_dot(const Outer &o, Inner Outer::*p) {
// CIR-AFTER: cir.return
// LLVM-LABEL: define {{.*}} @_Z12test_agg_dotRK5OuterMS_5Inner(
+// LLVM: %[[RETVAL_ADDR:.*]] = alloca %struct.Inner, align 4
// LLVM: %[[O_ADDR:.*]] = alloca ptr
// LLVM: %[[P_ADDR:.*]] = alloca i64
-// LLVM: %[[RETVAL_ADDR:.*]] = alloca %struct.Inner, align 4
// LLVM: store ptr %[[O_ARG:.*]], ptr %[[O_ADDR]]
// LLVM: store i64 %[[P_ARG:.*]], ptr %[[P_ADDR]]
// LLVM: %[[O:.*]] = load ptr, ptr %[[O_ADDR]]
@@ -557,9 +557,9 @@ Inner test_agg_arrow(const Outer *o, Inner Outer::*p) {
// CIR-BEFORE-LABEL: cir.func {{.*}} @_Z14test_agg_arrowPK5OuterMS_5Inner(
// CIR-BEFORE-SAME: %[[O_ARG:.*]]: !cir.ptr<!rec_Outer>
// CIR-BEFORE-SAME: %[[P_ARG:.*]]: !cir.data_member<!rec_Inner in !rec_Outer>
+// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-BEFORE: %[[O_ADDR:.*]] = cir.alloca "o" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Outer>>
// CIR-BEFORE: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.data_member<!rec_Inner in !rec_Outer>>
-// CIR-BEFORE: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-BEFORE: cir.store %[[O_ARG]], %[[O_ADDR]]
// CIR-BEFORE: cir.store %[[P_ARG]], %[[P_ADDR]]
// CIR-BEFORE: %[[O:.*]] = cir.load{{.*}} %[[O_ADDR]]
@@ -571,9 +571,9 @@ Inner test_agg_arrow(const Outer *o, Inner Outer::*p) {
// CIR-AFTER-LABEL: cir.func {{.*}} @_Z14test_agg_arrowPK5OuterMS_5Inner(
// CIR-AFTER-SAME: %[[O_ARG:.*]]: !cir.ptr<!rec_Outer>
// CIR-AFTER-SAME: %[[P_ARG:.*]]: !s64i
+// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-AFTER: %[[O_ADDR:.*]] = cir.alloca "o" {{.*}} init : !cir.ptr<!cir.ptr<!rec_Outer>>
// CIR-AFTER: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!s64i>
-// CIR-AFTER: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_Inner>
// CIR-AFTER: cir.store %[[O_ARG]], %[[O_ADDR]] : !cir.ptr<!rec_Outer>, !cir.ptr<!cir.ptr<!rec_Outer>>
// CIR-AFTER: cir.store %[[P_ARG]], %[[P_ADDR]] : !s64i, !cir.ptr<!s64i>
// CIR-AFTER: %[[O:.*]] = cir.load{{.*}} %[[O_ADDR]] : !cir.ptr<!cir.ptr<!rec_Outer>>, !cir.ptr<!rec_Outer>
@@ -585,9 +585,9 @@ Inner test_agg_arrow(const Outer *o, Inner Outer::*p) {
// CIR-AFTER: cir.return
// LLVM-LABEL: define {{.*}} @_Z14test_agg_arrowPK5OuterMS_5Inner(
+// LLVM: %[[RETVAL_ADDR:.*]] = alloca %struct.Inner, align 4
// LLVM: %[[O_ADDR:.*]] = alloca ptr
// LLVM: %[[P_ADDR:.*]] = alloca i64
-// LLVM: %[[RETVAL_ADDR:.*]] = alloca %struct.Inner, align 4
// LLVM: store ptr %[[O_ARG:.*]], ptr %[[O_ADDR]]
// LLVM: store i64 %[[P_ARG:.*]], ptr %[[P_ADDR]]
// LLVM: %[[O:.*]] = load ptr, ptr %[[O_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 850b9ef9a918ce..57369d500e7371 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func-cast.cpp
@@ -138,8 +138,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 : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !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>
@@ -207,8 +207,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 : !cir.ptr<!rec_anon_struct>
// CIR-AFTER: %[[RET:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!rec_anon_struct>
+// CIR-AFTER: %[[PTR:.*]] = cir.alloca "ptr" {{.*}} init : !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-cmp.cpp b/clang/test/CIR/CodeGen/pointer-to-member-func-cmp.cpp
index 65c68a73b78ca0..15e432ba332bd9 100644
--- a/clang/test/CIR/CodeGen/pointer-to-member-func-cmp.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-member-func-cmp.cpp
@@ -25,8 +25,8 @@ bool cmp_eq(void (Foo::*lhs)(int), void (Foo::*rhs)(int)) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z6cmp_eqM3FooFviES1_
-// CIR-BEFORE: %[[LHS:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
-// CIR-BEFORE: %[[RHS:.*]] = cir.load{{.*}} %1 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[LHS:.*]] = cir.load{{.*}} %1 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[RHS:.*]] = cir.load{{.*}} %2 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[CMP:.*]] = cir.cmp eq %[[LHS]], %[[RHS]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[CMP]], %{{.*}} : !cir.bool, !cir.ptr<!cir.bool>
@@ -101,8 +101,8 @@ bool cmp_ne(void (Foo::*lhs)(int), void (Foo::*rhs)(int)) {
}
// CIR-BEFORE: cir.func {{.*}} @_Z6cmp_neM3FooFviES1_
-// CIR-BEFORE: %[[LHS:.*]] = cir.load{{.*}} %0 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
-// CIR-BEFORE: %[[RHS:.*]] = cir.load{{.*}} %1 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[LHS:.*]] = cir.load{{.*}} %1 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
+// CIR-BEFORE: %[[RHS:.*]] = cir.load{{.*}} %2 : !cir.ptr<!cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>>
// CIR-BEFORE: %[[CMP:.*]] = cir.cmp ne %[[LHS]], %[[RHS]] : !cir.method<!cir.func<(!cir.ptr<!rec_Foo>, !s32i)> in !rec_Foo>
// CIR-BEFORE: cir.store %[[CMP]], %{{.*}} : !cir.bool, !cir.ptr<!cir.bool>
diff --git a/clang/test/CIR/CodeGen/requires-expr.cpp b/clang/test/CIR/CodeGen/requires-expr.cpp
index 310a7438a25cd6..4b5735d34d08a3 100644
--- a/clang/test/CIR/CodeGen/requires-expr.cpp
+++ b/clang/test/CIR/CodeGen/requires-expr.cpp
@@ -1,9 +1,9 @@
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
-// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM,LLVMCIR
+// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -Wno-unused-value -emit-llvm %s -o %t.ll
-// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM,OGCG
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM
template <typename T> void summable(T a) {
if (requires { a + a; }) {
@@ -21,12 +21,8 @@ template <typename T> void summable(T a) {
// CIR: cir.store {{.*}} %[[RESULT]], %[[B_ADDR]] : !s32i, !cir.ptr<!s32i>
// CIR: }
-// Classic codegen and CIR reverse the order of these allocas.
-// LLVMCIR: %[[B_ADDR:.*]] = alloca i32, align 4
-// LLVMCIR: %[[A_ADDR:.*]] = alloca i32, align 4
-//
-// OGCG: %[[A_ADDR:.*]] = alloca i32, align 4
-// OGCG: %[[B_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[A_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[B_ADDR:.*]] = alloca i32, align 4
//
// LLVM: %[[TMP_A_1:.*]] = load i32, ptr %[[A_ADDR]], align 4
// LLVM: %[[TMP_A_2:.*]] = load i32, ptr %[[A_ADDR]], align 4
diff --git a/clang/test/CIR/CodeGen/statement-exprs.c b/clang/test/CIR/CodeGen/statement-exprs.c
index 13fb54aef7bb9a..947291d8136526 100644
--- a/clang/test/CIR/CodeGen/statement-exprs.c
+++ b/clang/test/CIR/CodeGen/statement-exprs.c
@@ -103,13 +103,13 @@ int nested(void) {
// CIR: cir.return %[[FINAL_RES]] : !s32i
// LLVM: define dso_local i32 @nested()
+// LLVM: %[[VAR6:.+]] = alloca i32,
+// LLVM: %[[VAR7:.+]] = alloca i32,
// LLVM: %[[VAR1:.+]] = alloca i32,
// LLVM: %[[VAR2:.+]] = alloca i32,
// LLVM: %[[VAR3:.+]] = alloca i32,
// LLVM: %[[VAR4:.+]] = alloca i32,
// LLVM: %[[VAR5:.+]] = alloca i32,
-// LLVM: %[[VAR6:.+]] = alloca i32,
-// LLVM: %[[VAR7:.+]] = alloca i32,
// LLVM: br label %[[LBL8:.+]]
// LLVM: [[LBL8]]:
// LLVM: store i32 123, ptr %[[VAR7]]
@@ -204,8 +204,8 @@ void test2() { ({int x = 3; x; }); }
// CIR: %{{.+}} = cir.load{{.*}} %[[RETVAL]] : !cir.ptr<!s32i>, !s32i
// LLVM: define dso_local void @test2()
-// LLVM: %[[X:.+]] = alloca i32,
// LLVM: %[[TMP:.+]] = alloca i32,
+// LLVM: %[[X:.+]] = alloca i32,
// LLVM: br label %[[LBL3:.+]]
// LLVM: [[LBL3]]:
// LLVM: store i32 3, ptr %[[X]]
@@ -245,10 +245,10 @@ int test3() { return ({ struct S s = {1}; s; }).x; }
// CIR: cir.return %[[RES]] : !s32i
// LLVM: define dso_local i32 @test3()
-// LLVM: %[[VAR1:.+]] = alloca %struct.S,
// LLVM: %[[VAR2:.+]] = alloca i32,
// LLVM: %[[VAR3:.+]] = alloca %struct.S,
// LLVM: %[[VAR4:.+]] = alloca %struct.S,
+// LLVM: %[[VAR1:.+]] = alloca %struct.S,
// LLVM: br label %[[LBL5:.+]]
// LLVM: [[LBL5]]:
// LLVM: call void @llvm.memcpy{{.*}}(ptr align 4 %[[VAR1]], ptr align 4 @[[TEST3_S]], i64 4, i1 false)
diff --git a/clang/test/CIR/CodeGen/static-local.cpp b/clang/test/CIR/CodeGen/static-local.cpp
index bc2d172be1657a..c2e4fc00544907 100644
--- a/clang/test/CIR/CodeGen/static-local.cpp
+++ b/clang/test/CIR/CodeGen/static-local.cpp
@@ -677,8 +677,8 @@ int referenced_inside() {
// CIR-BOTH: }
//
// CIR-BOTH-LABEL: cir.func no_inline lambda alignment(2) internal private dso_local @_ZZ17referenced_insidevENK3$_0clEv(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!{{.*}}>>
// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!{{.*}}>>
// 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
@@ -738,8 +738,8 @@ int referenced_inside_const() {
// CIR-BOTH: }
//
// CIR-BOTH-LABEL: cir.func no_inline lambda alignment(2) internal private dso_local @_ZZ23referenced_inside_constvENK3$_0clEv(
-// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!{{.*}}>>
// CIR-BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR-BOTH: %[[THIS_ALLOCA:.*]] = cir.alloca "this" {{.*}} init : !cir.ptr<!cir.ptr<!{{.*}}>>
// 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
diff --git a/clang/test/CIR/CodeGen/stmt-expr.cpp b/clang/test/CIR/CodeGen/stmt-expr.cpp
index 07701f8b586213..ab91e154dab6a0 100644
--- a/clang/test/CIR/CodeGen/stmt-expr.cpp
+++ b/clang/test/CIR/CodeGen/stmt-expr.cpp
@@ -32,9 +32,9 @@ void test1() {
// CIR: cir.return
// LLVM: define dso_local void @_Z5test1v()
-// LLVM: %[[A:.+]] = alloca %class.A,
// LLVM: %[[REF_TMP:.+]] = alloca %class.A,
// LLVM: %[[TMP:.+]] = alloca %class.A,
+// LLVM: %[[A:.+]] = alloca %class.A,
// LLVM: br label %[[LBL4:.+]]
// LLVM: [[LBL4]]:
// LLVM: call void @_ZN1AC2Ev(ptr {{.*}} %[[A]])
@@ -103,9 +103,9 @@ void gnu_statement_extension() {
// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> -> !cir.float
// CIR: cir.store {{.*}} %[[REAL]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
-// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, align 4
// LLVM: %[[B_ADDR:.*]] = alloca float, align 4
// LLVM: %[[TMP_ADDR:.*]] = alloca { float, float }, align 4
+// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, align 4
// LLVM: br label %[[LABEL_1:.*]]
// LLVM: [[LABEL_1]]:
// LLVM: %[[TMP_A:.*]] = load { float, float }, ptr %[[A_ADDR]], align 4
diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c
index 09f4fc4e262661..7bb9f553a32bda 100644
--- a/clang/test/CIR/CodeGen/struct.c
+++ b/clang/test/CIR/CodeGen/struct.c
@@ -202,8 +202,8 @@ char f3(int a) {
}
// CIR: cir.func{{.*}} @f3(%[[ARG_A:.*]]: !s32i
-// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" align(4) init
// CIR-NEXT: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(1)
+// CIR-NEXT: %[[A_ADDR:.*]] = cir.alloca "a" align(4) init
// CIR-NEXT: cir.store{{.*}} %[[ARG_A]], %[[A_ADDR]]
// CIR-NEXT: %[[A_VAL:.*]] = cir.load{{.*}} %[[A_ADDR]]
// CIR-NEXT: %[[CS:.*]] = cir.get_global @cs
@@ -217,8 +217,8 @@ char f3(int a) {
// CIR-NEXT: cir.return %[[RETVAL]]
// LLVM: define{{.*}} i8 @f3(i32{{.*}} %[[ARG_A:.*]])
-// LLVM-NEXT: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[RETVAL_ADDR:.*]] = alloca i8, align 1
+// LLVM-NEXT: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM-NEXT: store i32 %[[ARG_A]], ptr %[[A_ADDR]], align 4
// LLVM-NEXT: %[[A_VAL:.*]] = load i32, ptr %[[A_ADDR]], align 4
// LLVM-NEXT: store i32 %[[A_VAL]], ptr @cs, align 4
@@ -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: %[[RETVAL_ADDR:.*]] = cir.alloca "__retval" align(1)
// 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]]
@@ -259,9 +259,9 @@ char f4(int a, struct CompleteS *p) {
// CIR-NEXT: cir.return %[[RETVAL]]
// LLVM: define{{.*}} i8 @f4(i32{{.*}} %[[ARG_A:.*]], ptr{{.*}} %[[ARG_P:.*]])
+// LLVM-NEXT: %[[RETVAL_ADDR:.*]] = alloca i8, align 1
// LLVM-NEXT: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[P_ADDR:.*]] = alloca ptr, align 8
-// LLVM-NEXT: %[[RETVAL_ADDR:.*]] = alloca i8, align 1
// LLVM-NEXT: store i32 %[[ARG_A]], ptr %[[A_ADDR]], align 4
// LLVM-NEXT: store ptr %[[ARG_P]], ptr %[[P_ADDR]], align 8
// LLVM-NEXT: %[[A_VAL:.*]] = load i32, ptr %[[A_ADDR]], align 4
diff --git a/clang/test/CIR/CodeGen/switch.cpp b/clang/test/CIR/CodeGen/switch.cpp
index 2deebb23c92a33..0d3d3d1ae9238d 100644
--- a/clang/test/CIR/CodeGen/switch.cpp
+++ b/clang/test/CIR/CodeGen/switch.cpp
@@ -216,8 +216,8 @@ int sw4(int a) {
// CIR-NEXT: }
// LLVM: define{{.*}} i32 @_Z3sw4i
-// LLVM: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[RET_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM: br label %[[ENTRY:.*]]
// LLVM: [[ENTRY]]:
// LLVM: %[[A_VAL:.*]] = load i32, ptr %[[A_ADDR]], align 4
@@ -1082,9 +1082,9 @@ int nested_switch(int a) {
// CIR: cir.return
// LLVM: define{{.*}} i32 @_Z13nested_switchi
-// LLVM: %[[B_ADDR:.*]] = alloca i32, align 4
-// LLVM: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[RES_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[A_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[B_ADDR:.*]] = alloca i32, align 4
// LLVM: store i32 %[[ARG:.*]], ptr %[[A_ADDR]], align 4
// LLVM: br label %[[ENTRY:.*]]
// LLVM: [[ENTRY]]:
diff --git a/clang/test/CIR/CodeGen/temporary-materialization.cpp b/clang/test/CIR/CodeGen/temporary-materialization.cpp
index 15d48a01f2a6e1..cc69b635f526ad 100644
--- a/clang/test/CIR/CodeGen/temporary-materialization.cpp
+++ b/clang/test/CIR/CodeGen/temporary-materialization.cpp
@@ -57,10 +57,10 @@ int test_scoped() {
// CIR-NEXT: }
// LLVM: define {{.*}} i32 @_Z11test_scopedv()
-// LLVM: %[[TEMP_SLOT:.*]] = alloca i32
-// LLVM: %[[Y_ADDR:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
// LLVM: %[[X:.*]] = alloca i32
+// LLVM: %[[TEMP_SLOT:.*]] = alloca i32
+// LLVM: %[[Y_ADDR:.*]] = alloca ptr
// LLVM: %[[TEMP_VALUE1:.*]] = call noundef i32 @_Z8make_intv()
// LLVM: store i32 %[[TEMP_VALUE1]], ptr %[[X]]
// LLVM: br label %[[SCOPE_LABEL:.*]]
@@ -90,8 +90,8 @@ int test_rvalue_reference(int&& ri) {
}
// CIR: cir.func {{.*}} @_Z21test_rvalue_referenceOi({{.*}})
-// CIR: %[[RI:.*]] = cir.alloca "ri" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
-// CIR-NEXT: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[RETVAL:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR-NEXT: %[[RI:.*]] = cir.alloca "ri" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
// CIR-NEXT: %[[TEMP_SLOT:.*]] = cir.alloca "ref.tmp0" {{.*}} : !cir.ptr<!s32i>
// CIR-NEXT: cir.store{{.*}} {{.*}}, %[[RI]]
// CIR-NEXT: %[[RI_REF:.*]] = cir.load %[[RI]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
@@ -102,8 +102,8 @@ int test_rvalue_reference(int&& ri) {
// CIR-NEXT: %[[TEMP_VALUE:.*]] = cir.load{{.*}} %[[TEMP_SLOT]] : !cir.ptr<!s32i>, !s32i
// LLVM: define {{.*}} i32 @_Z21test_rvalue_referenceOi({{.*}})
-// LLVM: %[[RI:.*]] = alloca ptr
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[RI:.*]] = alloca ptr
// LLVM: %[[TEMP_SLOT:.*]] = alloca i32
// LLVM: store ptr {{.*}}, ptr %[[RI]]
// LLVM: %[[RI_REF:.*]] = load ptr, ptr %[[RI]]
diff --git a/clang/test/CIR/CodeGen/ternary-throw.cpp b/clang/test/CIR/CodeGen/ternary-throw.cpp
index ec617bea1c930b..4c75f66cf1f9c3 100644
--- a/clang/test/CIR/CodeGen/ternary-throw.cpp
+++ b/clang/test/CIR/CodeGen/ternary-throw.cpp
@@ -27,8 +27,8 @@ const int& test_cond_throw_false(bool flag) {
// CIR-NEXT: }) : (!cir.bool) -> !cir.ptr<!s32i>
// LLVM-LABEL: define{{.*}} ptr @_Z21test_cond_throw_falseb(
-// LLVM: %[[FLAG_ALLOCA:.*]] = alloca i8
// LLVM: %[[RET_ALLOCA:.*]] = alloca ptr
+// LLVM: %[[FLAG_ALLOCA:.*]] = alloca i8
// LLVM: %[[A_ALLOCA:.*]] = alloca i32
// LLVM: %[[ZEXT:.*]] = zext i1 %{{.*}} to i8
// LLVM: store i8 %[[ZEXT]], ptr %[[FLAG_ALLOCA]]
@@ -90,8 +90,8 @@ const int& test_cond_throw_true(bool flag) {
// CIR-NEXT: }) : (!cir.bool) -> !cir.ptr<!s32i>
// LLVM-LABEL: define{{.*}} ptr @_Z20test_cond_throw_trueb(
-// LLVM: %[[FLAG_ALLOCA:.*]] = alloca i8
// LLVM: %[[RET_ALLOCA:.*]] = alloca ptr
+// LLVM: %[[FLAG_ALLOCA:.*]] = alloca i8
// LLVM: %[[A_ALLOCA:.*]] = alloca i32
// LLVM: %[[ZEXT:.*]] = zext i1 %{{.*}} to i8
// LLVM: store i8 %[[ZEXT]], ptr %[[FLAG_ALLOCA]]
@@ -749,9 +749,9 @@ int &test_ref_cond_throw(bool c, int &x) {
}
// CIR-LABEL: cir.func{{.*}} @_Z19test_ref_cond_throwbRi(
+// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[C:.*]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.bool>
// CIR: %[[X_REF:.*]] = cir.alloca "x" {{.*}} init const : !cir.ptr<!cir.ptr<!s32i>>
-// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
// CIR: %[[C_VAL:.*]] = cir.load{{.*}} %[[C]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR: %[[RES:.*]] = cir.ternary(%[[C_VAL]], true {
// CIR: %[[X_PTR:.*]] = cir.load %[[X_REF]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGen/ternary.cpp b/clang/test/CIR/CodeGen/ternary.cpp
index a7b82a84125de1..7e3f5ace0061d0 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 : !cir.ptr<!s32i>
// CIR: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: [[Y:%.+]] = cir.alloca "y" {{.*}} init : !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
@@ -26,8 +26,8 @@ int x(int y) {
// LLVM-LABEL: define{{.*}} i32 @_Z1xi(
// LLVM-SAME: i32 {{.*}} %[[ARG0:.+]])
-// LLVM: %[[Y:.*]] = alloca i32
// LLVM: %[[RETVAL:.*]] = alloca i32
+// LLVM: %[[Y:.*]] = alloca i32
// LLVM: store i32 %[[ARG0]], ptr %[[Y]]
// LLVM: %[[YVAL:.*]] = load i32, ptr %[[Y]]
// LLVM: %[[CMP:.*]] = icmp sgt i32 %[[YVAL]], 0
@@ -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: [[RETVAL:%.+]] = cir.alloca "__retval" {{.*}} : !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 {
@@ -84,9 +84,9 @@ int foo(int a, int b) {
// LLVM-LABEL: define{{.*}} i32 @_Z3fooii(
// LLVM-SAME: i32 {{.*}} %[[ARG0:.*]], i32 {{.*}} %[[ARG1:.*]])
+// LLVM: %[[RETVAL:.*]] = alloca i32
// LLVM: %[[A:.*]] = alloca i32
// LLVM: %[[B:.*]] = alloca i32
-// LLVM: %[[RETVAL:.*]] = alloca i32
// LLVM: store i32 %[[ARG0]], ptr %[[A]]
// LLVM: store i32 %[[ARG1]], ptr %[[B]]
// LLVM: br label %[[ENTRY_BB:.*]]
diff --git a/clang/test/CIR/CodeGen/three-way-cmp.cpp b/clang/test/CIR/CodeGen/three-way-cmp.cpp
index c522e66d9edc77..a02387126d5462 100644
--- a/clang/test/CIR/CodeGen/three-way-cmp.cpp
+++ b/clang/test/CIR/CodeGen/three-way-cmp.cpp
@@ -45,9 +45,9 @@ auto three_way_strong(int x, int y) {
// FINAL-NEXT: cir.return %[[COERCED]] : !s8i
// LLVM: define dso_local i8 @_Z16three_way_strongii(i32 noundef %[[X:.*]], i32 noundef %[[Y:.*]])
+// LLVM: %[[RETVAL:.*]] = alloca %"class.std::__1::strong_ordering", align 1
// LLVM: %[[X_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[Y_ADDR:.*]] = alloca i32, align 4
-// LLVM: %[[RETVAL:.*]] = alloca %"class.std::__1::strong_ordering", align 1
// LLVM: store i32 %[[X]], ptr %[[X_ADDR]], align 4
// LLVM-NEXT: store i32 %[[Y]], ptr %[[Y_ADDR]], align 4
// LLVM-NEXT: %[[LHS:.*]] = load i32, ptr %[[X_ADDR]], align 4
@@ -99,9 +99,9 @@ auto three_way_partial(float x, float y) {
// FINAL-NEXT: cir.return %[[COERCED]] : !s8i
// LLVM: define dso_local i8 @_Z17three_way_partialff(float noundef %[[X:.*]], float noundef %[[Y:.*]])
+// LLVM: %[[RETVAL:.*]] = alloca %"class.std::__1::partial_ordering", align 1
// LLVM: %[[X_ADDR:.*]] = alloca float, align 4
// LLVM: %[[Y_ADDR:.*]] = alloca float, align 4
-// LLVM: %[[RETVAL:.*]] = alloca %"class.std::__1::partial_ordering", align 1
// LLVM: store float %[[X]], ptr %[[X_ADDR]], align 4
// LLVM-NEXT: store float %[[Y]], ptr %[[Y_ADDR]], align 4
// LLVM-NEXT: %[[LHS:.*]] = load float, ptr %[[X_ADDR]], align 4
@@ -145,9 +145,9 @@ void use_pseudo_ordering(HasMember m1, HasMember m2) {
// BOTH: cir.store {{.*}}%[[CALL_RES]], %[[G_ALLOCA]] : !rec_std3A3A__13A3Astrong_ordering, !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
// BOTH: cir.func {{.*}}@_ZNK9HasMemberssERKS_(%{{.*}}: !cir.ptr<!rec_HasMember>{{.*}}, %{{.*}}: !cir.ptr<!rec_HasMember>{{.*}}) -> !rec_std3A3A__13A3Astrong_ordering
+ // BOTH: %[[RET_ALLOCA:.*]] = cir.alloca "__retval" {{.*}} : !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 : !cir.ptr<!rec_std3A3A__13A3Astrong_ordering>
@@ -202,12 +202,12 @@ void use_pseudo_ordering(HasMember m1, HasMember m2) {
// LLVM: }
// LLVM: define {{.*}} i8 @_ZNK9HasMemberssERKS_(ptr {{.*}}, ptr {{.*}})
- // LLVM: %[[CMP_COPY:.*]] = alloca %"class.std::__1::strong_ordering"
- // LLVM: %[[CMP_TEMP:.*]] = alloca %"class.std::__1::strong_ordering"
// LLVM: %[[VALUE_SLOT:.*]] = alloca %"class.std::__1::strong_ordering"
+ // LLVM: %[[RESULT_SLOT:.*]] = alloca %"class.std::__1::strong_ordering"
// LLVM: %[[LHS_ALLOCA:.*]] = alloca ptr
// LLVM: %[[RHS_ALLOCA:.*]] = alloca ptr
- // LLVM: %[[RESULT_SLOT:.*]] = alloca %"class.std::__1::strong_ordering"
+ // LLVM: %[[CMP_COPY:.*]] = alloca %"class.std::__1::strong_ordering"
+ // LLVM: %[[CMP_TEMP:.*]] = alloca %"class.std::__1::strong_ordering"
// LLVM: %[[LHS_LOAD:.*]] = load ptr, ptr %[[LHS_ALLOCA]]
// LLVM: br label %[[ENTRY_CONT:.*]]
//
diff --git a/clang/test/CIR/CodeGen/throws.cpp b/clang/test/CIR/CodeGen/throws.cpp
index 4023f41e2c1684..5e469e141e7067 100644
--- a/clang/test/CIR/CodeGen/throws.cpp
+++ b/clang/test/CIR/CodeGen/throws.cpp
@@ -163,9 +163,9 @@ int rethrow_from_block(int a, int b) {
return a / b;
}
+// CIR: %[[RES_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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 {
@@ -184,9 +184,9 @@ int rethrow_from_block(int a, int b) {
// CIR: %[[RESULT:.*]] = cir.load %[[RES_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: cir.return %[[RESULT]] : !s32i
+// LLVM: %[[RES_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[A_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[B_ADDR:.*]] = alloca i32, align 4
-// LLVM: %[[RES_ADDR:.*]] = alloca i32, align 4
// LLVM: store i32 %{{.*}}, ptr %[[A_ADDR]], align 4
// LLVM: store i32 %{{.*}}, ptr %[[B_ADDR]], align 4
// LLVM: br label %[[CHECK_COND:.*]]
diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp
index 68d00449a304f7..74f30831d3e190 100644
--- a/clang/test/CIR/CodeGen/try-catch.cpp
+++ b/clang/test/CIR/CodeGen/try-catch.cpp
@@ -1381,9 +1381,9 @@ int init_catch_param_with_type_int() {
// CIR: cir.return %[[TMP_RET]] : !s32i
// LLVM: define {{.*}} i32 @_Z30init_catch_param_with_type_intv() {{.*}} personality ptr @__gxx_personality_v0
-// LLVM: %[[X_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[RET_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[RV_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[X_ADDR:.*]] = alloca i32, align 4
// LLVM: br label %[[TRY_SCOPE:.*]]
// LLVM: [[TRY_SCOPE]]:
// LLVM: br label %[[TRY_BEGIN:.*]]
@@ -1523,9 +1523,9 @@ int init_catch_param_with_type_int_ptr() {
// CIR: cir.return %[[TMP_RET]] : !s32i
// LLVM: define {{.*}} i32 @_Z34init_catch_param_with_type_int_ptrv() {{.*}} personality ptr @__gxx_personality_v0
-// LLVM: %[[X_ADDR:.*]] = alloca ptr, align 8
// LLVM: %[[RET_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[RV_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[X_ADDR:.*]] = alloca ptr, align 8
// LLVM: br label %[[TRY_SCOPE:.*]]
// LLVM: [[TRY_SCOPE]]:
// LLVM: br label %[[TRY_BEGIN:.*]]
@@ -1666,9 +1666,9 @@ int init_catch_param_with_ref_to_ptr_to_non_record() {
// CIR: cir.return %[[TMP_RET]] : !s32i
// LLVM: define {{.*}} i32 @_Z46init_catch_param_with_ref_to_ptr_to_non_recordv() {{.*}} personality ptr @__gxx_personality_v0
-// LLVM: %[[P_ADDR:.*]] = alloca ptr, align 8
// LLVM: %[[RET_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[RV_ADDR:.*]] = alloca i32, align 4
+// LLVM: %[[P_ADDR:.*]] = alloca ptr, align 8
// LLVM: br label %[[TRY_SCOPE:.*]]
// LLVM: [[TRY_SCOPE]]:
// LLVM: br label %[[TRY_BEGIN:.*]]
diff --git a/clang/test/CIR/CodeGen/unary.cpp b/clang/test/CIR/CodeGen/unary.cpp
index 344b0374bd2fb1..9e9d333088beda 100644
--- a/clang/test/CIR/CodeGen/unary.cpp
+++ b/clang/test/CIR/CodeGen/unary.cpp
@@ -524,8 +524,8 @@ double doubleUPreInc(double f) {
}
// CIR: cir.func{{.*}} @_Z13doubleUPreIncd({{.*}}) -> (!cir.double{{.*}})
-// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.double>
+// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[DBL_LOAD:.*]] = cir.load{{.*}} %[[DBL_F]]
// CIR: %[[DBL_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.double
// CIR: %[[DBL_INC:.*]] = cir.fadd %[[DBL_LOAD]], %[[DBL_ONE]]
@@ -535,8 +535,8 @@ double doubleUPreInc(double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.double
// LLVM: define{{.*}} double @_Z13doubleUPreIncd({{.*}})
-// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: %[[RV:.*]] = alloca double, align 8
+// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: store double %{{.*}}, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_LOAD:.*]] = load double, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_INC:.*]] = fadd double %[[DBL_LOAD]], 1.000000e+00
@@ -558,8 +558,8 @@ double doubleUPreDec(double f) {
}
// CIR: cir.func{{.*}} @_Z13doubleUPreDecd({{.*}}) -> (!cir.double{{.*}})
-// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.double>
+// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[DBL_LOAD:.*]] = cir.load{{.*}} %[[DBL_F]]
// CIR: %[[DBL_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.double
// CIR: %[[DBL_DEC:.*]] = cir.fadd %[[DBL_LOAD]], %[[DBL_NEGONE]]
@@ -569,8 +569,8 @@ double doubleUPreDec(double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.double
// LLVM: define{{.*}} double @_Z13doubleUPreDecd({{.*}})
-// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: %[[RV:.*]] = alloca double, align 8
+// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: store double %{{.*}}, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_LOAD:.*]] = load double, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_DEC:.*]] = fadd double %[[DBL_LOAD]], -1.000000e+00
@@ -592,8 +592,8 @@ double doubleUPostInc(double f) {
}
// CIR: cir.func{{.*}} @_Z14doubleUPostIncd({{.*}}) -> (!cir.double{{.*}})
-// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.double>
+// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[DBL_LOAD:.*]] = cir.load{{.*}} %[[DBL_F]]
// CIR: %[[DBL_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.double
// CIR: %[[DBL_INC:.*]] = cir.fadd %[[DBL_LOAD]], %[[DBL_ONE]]
@@ -603,8 +603,8 @@ double doubleUPostInc(double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.double
// LLVM: define{{.*}} double @_Z14doubleUPostIncd({{.*}})
-// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: %[[RV:.*]] = alloca double, align 8
+// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: store double %{{.*}}, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_LOAD:.*]] = load double, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_INC:.*]] = fadd double %[[DBL_LOAD]], 1.000000e+00
@@ -626,8 +626,8 @@ double doubleUPostDec(double f) {
}
// CIR: cir.func{{.*}} @_Z14doubleUPostDecd({{.*}}) -> (!cir.double{{.*}})
-// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.double>
+// CIR: %[[DBL_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.double>
// CIR: %[[DBL_LOAD:.*]] = cir.load{{.*}} %[[DBL_F]]
// CIR: %[[DBL_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.double
// CIR: %[[DBL_DEC:.*]] = cir.fadd %[[DBL_LOAD]], %[[DBL_NEGONE]]
@@ -637,8 +637,8 @@ double doubleUPostDec(double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.double
// LLVM: define{{.*}} double @_Z14doubleUPostDecd({{.*}})
-// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: %[[RV:.*]] = alloca double, align 8
+// LLVM: %[[DBL_F:.*]] = alloca double, align 8
// LLVM: store double %{{.*}}, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_LOAD:.*]] = load double, ptr %[[DBL_F]], align 8
// LLVM: %[[DBL_DEC:.*]] = fadd double %[[DBL_LOAD]], -1.000000e+00
@@ -692,8 +692,8 @@ long double ldUPreInc(long double f) {
}
// CIR: cir.func{{.*}} @_Z9ldUPreInce({{.*}}) -> (!cir.long_double<!cir.f80>{{.*}})
-// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.long_double<!cir.f80>>
+// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[LD_LOAD:.*]] = cir.load{{.*}} %[[LD_F]]
// CIR: %[[LD_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.long_double<!cir.f80>
// CIR: %[[LD_INC:.*]] = cir.fadd %[[LD_LOAD]], %[[LD_ONE]]
@@ -703,8 +703,8 @@ long double ldUPreInc(long double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.long_double<!cir.f80>
// LLVM: define{{.*}} x86_fp80 @_Z9ldUPreInce({{.*}})
-// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: %[[RV:.*]] = alloca x86_fp80, align 16
+// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: store x86_fp80 %{{.*}}, ptr %[[LD_F]], align 16
// LLVM: %[[LD_LOAD:.*]] = load x86_fp80, ptr %[[LD_F]], align 16
// LLVM: %[[LD_INC:.*]] = fadd x86_fp80 %[[LD_LOAD]], 1.000000e+00
@@ -726,8 +726,8 @@ long double ldUPreDec(long double f) {
}
// CIR: cir.func{{.*}} @_Z9ldUPreDece({{.*}}) -> (!cir.long_double<!cir.f80>{{.*}})
-// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.long_double<!cir.f80>>
+// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[LD_LOAD:.*]] = cir.load{{.*}} %[[LD_F]]
// CIR: %[[LD_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.long_double<!cir.f80>
// CIR: %[[LD_DEC:.*]] = cir.fadd %[[LD_LOAD]], %[[LD_NEGONE]]
@@ -737,8 +737,8 @@ long double ldUPreDec(long double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.long_double<!cir.f80>
// LLVM: define{{.*}} x86_fp80 @_Z9ldUPreDece({{.*}})
-// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: %[[RV:.*]] = alloca x86_fp80, align 16
+// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: store x86_fp80 %{{.*}}, ptr %[[LD_F]], align 16
// LLVM: %[[LD_LOAD:.*]] = load x86_fp80, ptr %[[LD_F]], align 16
// LLVM: %[[LD_DEC:.*]] = fadd x86_fp80 %[[LD_LOAD]], -1.000000e+00
@@ -760,8 +760,8 @@ long double ldUPostInc(long double f) {
}
// CIR: cir.func{{.*}} @_Z10ldUPostInce({{.*}}) -> (!cir.long_double<!cir.f80>{{.*}})
-// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.long_double<!cir.f80>>
+// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[LD_LOAD:.*]] = cir.load{{.*}} %[[LD_F]]
// CIR: %[[LD_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.long_double<!cir.f80>
// CIR: %[[LD_INC:.*]] = cir.fadd %[[LD_LOAD]], %[[LD_ONE]]
@@ -771,8 +771,8 @@ long double ldUPostInc(long double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.long_double<!cir.f80>
// LLVM: define{{.*}} x86_fp80 @_Z10ldUPostInce({{.*}})
-// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: %[[RV:.*]] = alloca x86_fp80, align 16
+// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: store x86_fp80 %{{.*}}, ptr %[[LD_F]], align 16
// LLVM: %[[LD_LOAD:.*]] = load x86_fp80, ptr %[[LD_F]], align 16
// LLVM: %[[LD_INC:.*]] = fadd x86_fp80 %[[LD_LOAD]], 1.000000e+00
@@ -794,8 +794,8 @@ long double ldUPostDec(long double f) {
}
// CIR: cir.func{{.*}} @_Z10ldUPostDece({{.*}}) -> (!cir.long_double<!cir.f80>{{.*}})
-// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.long_double<!cir.f80>>
+// CIR: %[[LD_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.long_double<!cir.f80>>
// CIR: %[[LD_LOAD:.*]] = cir.load{{.*}} %[[LD_F]]
// CIR: %[[LD_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.long_double<!cir.f80>
// CIR: %[[LD_DEC:.*]] = cir.fadd %[[LD_LOAD]], %[[LD_NEGONE]]
@@ -805,8 +805,8 @@ long double ldUPostDec(long double f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.long_double<!cir.f80>
// LLVM: define{{.*}} x86_fp80 @_Z10ldUPostDece({{.*}})
-// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: %[[RV:.*]] = alloca x86_fp80, align 16
+// LLVM: %[[LD_F:.*]] = alloca x86_fp80, align 16
// LLVM: store x86_fp80 %{{.*}}, ptr %[[LD_F]], align 16
// LLVM: %[[LD_LOAD:.*]] = load x86_fp80, ptr %[[LD_F]], align 16
// LLVM: %[[LD_DEC:.*]] = fadd x86_fp80 %[[LD_LOAD]], -1.000000e+00
@@ -860,8 +860,8 @@ __float128 f128UPreInc(__float128 f) {
}
// CIR: cir.func{{.*}} @_Z11f128UPreIncg({{.*}}) -> (!cir.f128{{.*}})
-// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f128>
+// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[F128_LOAD:.*]] = cir.load{{.*}} %[[F128_F]]
// CIR: %[[F128_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.f128
// CIR: %[[F128_INC:.*]] = cir.fadd %[[F128_LOAD]], %[[F128_ONE]]
@@ -871,8 +871,8 @@ __float128 f128UPreInc(__float128 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f128
// LLVM: define{{.*}} fp128 @_Z11f128UPreIncg({{.*}})
-// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: %[[RV:.*]] = alloca fp128, align 16
+// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: store fp128 %{{.*}}, ptr %[[F128_F]], align 16
// LLVM: %[[F128_LOAD:.*]] = load fp128, ptr %[[F128_F]], align 16
// LLVM: %[[F128_INC:.*]] = fadd fp128 %[[F128_LOAD]], 1.000000e+00
@@ -894,8 +894,8 @@ __float128 f128UPreDec(__float128 f) {
}
// CIR: cir.func{{.*}} @_Z11f128UPreDecg({{.*}}) -> (!cir.f128{{.*}})
-// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f128>
+// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[F128_LOAD:.*]] = cir.load{{.*}} %[[F128_F]]
// CIR: %[[F128_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.f128
// CIR: %[[F128_DEC:.*]] = cir.fadd %[[F128_LOAD]], %[[F128_NEGONE]]
@@ -905,8 +905,8 @@ __float128 f128UPreDec(__float128 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f128
// LLVM: define{{.*}} fp128 @_Z11f128UPreDecg({{.*}})
-// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: %[[RV:.*]] = alloca fp128, align 16
+// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: store fp128 %{{.*}}, ptr %[[F128_F]], align 16
// LLVM: %[[F128_LOAD:.*]] = load fp128, ptr %[[F128_F]], align 16
// LLVM: %[[F128_DEC:.*]] = fadd fp128 %[[F128_LOAD]], -1.000000e+00
@@ -928,8 +928,8 @@ __float128 f128UPostInc(__float128 f) {
}
// CIR: cir.func{{.*}} @_Z12f128UPostIncg({{.*}}) -> (!cir.f128{{.*}})
-// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f128>
+// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[F128_LOAD:.*]] = cir.load{{.*}} %[[F128_F]]
// CIR: %[[F128_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.f128
// CIR: %[[F128_INC:.*]] = cir.fadd %[[F128_LOAD]], %[[F128_ONE]]
@@ -939,8 +939,8 @@ __float128 f128UPostInc(__float128 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f128
// LLVM: define{{.*}} fp128 @_Z12f128UPostIncg({{.*}})
-// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: %[[RV:.*]] = alloca fp128, align 16
+// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: store fp128 %{{.*}}, ptr %[[F128_F]], align 16
// LLVM: %[[F128_LOAD:.*]] = load fp128, ptr %[[F128_F]], align 16
// LLVM: %[[F128_INC:.*]] = fadd fp128 %[[F128_LOAD]], 1.000000e+00
@@ -962,8 +962,8 @@ __float128 f128UPostDec(__float128 f) {
}
// CIR: cir.func{{.*}} @_Z12f128UPostDecg({{.*}}) -> (!cir.f128{{.*}})
-// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f128>
+// CIR: %[[F128_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f128>
// CIR: %[[F128_LOAD:.*]] = cir.load{{.*}} %[[F128_F]]
// CIR: %[[F128_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.f128
// CIR: %[[F128_DEC:.*]] = cir.fadd %[[F128_LOAD]], %[[F128_NEGONE]]
@@ -973,8 +973,8 @@ __float128 f128UPostDec(__float128 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f128
// LLVM: define{{.*}} fp128 @_Z12f128UPostDecg({{.*}})
-// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: %[[RV:.*]] = alloca fp128, align 16
+// LLVM: %[[F128_F:.*]] = alloca fp128, align 16
// LLVM: store fp128 %{{.*}}, ptr %[[F128_F]], align 16
// LLVM: %[[F128_LOAD:.*]] = load fp128, ptr %[[F128_F]], align 16
// LLVM: %[[F128_DEC:.*]] = fadd fp128 %[[F128_LOAD]], -1.000000e+00
@@ -1038,8 +1038,8 @@ _Float16 Float16UPreInc(_Float16 f) {
}
// CIR: cir.func{{.*}} @_Z14Float16UPreIncDF16_({{.*}}) -> (!cir.f16{{.*}})
-// CIR: %[[PREINC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f16>
+// CIR: %[[PREINC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[PREINC_INPUT:.*]] = cir.load{{.*}} %[[PREINC_F]]
// CIR: %[[PREINC_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.f16
// CIR: %[[PREINC_RESULT:.*]] = cir.fadd %[[PREINC_INPUT]], %[[PREINC_ONE]] : !cir.f16
@@ -1049,8 +1049,8 @@ _Float16 Float16UPreInc(_Float16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f16
// LLVM: define{{.*}} half @_Z14Float16UPreIncDF16_({{.*}})
-// LLVM: %[[PREINC_F_ADDR:.*]] = alloca half, align 2
// LLVM: %[[RV:.*]] = alloca half, align 2
+// LLVM: %[[PREINC_F_ADDR:.*]] = alloca half, align 2
// LLVM: store half %{{.*}}, ptr %[[PREINC_F_ADDR]], align 2
// LLVM: %[[PREINC_INPUT:.*]] = load half, ptr %[[PREINC_F_ADDR]], align 2
// LLVM: %[[PREINC_RESULT:.*]] = fadd half %[[PREINC_INPUT]], 1.000000e+00
@@ -1072,8 +1072,8 @@ _Float16 Float16UPreDec(_Float16 f) {
}
// CIR: cir.func{{.*}} @_Z14Float16UPreDecDF16_({{.*}}) -> (!cir.f16{{.*}})
-// CIR: %[[PREDEC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f16>
+// CIR: %[[PREDEC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[PREDEC_INPUT:.*]] = cir.load{{.*}} %[[PREDEC_F]]
// CIR: %[[PREDEC_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.f16
// CIR: %[[PREDEC_RESULT:.*]] = cir.fadd %[[PREDEC_INPUT]], %[[PREDEC_NEGONE]] : !cir.f16
@@ -1083,8 +1083,8 @@ _Float16 Float16UPreDec(_Float16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f16
// LLVM: define{{.*}} half @_Z14Float16UPreDecDF16_({{.*}})
-// LLVM: %[[PREDEC_F_ADDR:.*]] = alloca half, align 2
// LLVM: %[[RV:.*]] = alloca half, align 2
+// LLVM: %[[PREDEC_F_ADDR:.*]] = alloca half, align 2
// LLVM: store half %{{.*}}, ptr %[[PREDEC_F_ADDR]], align 2
// LLVM: %[[PREDEC_INPUT:.*]] = load half, ptr %[[PREDEC_F_ADDR]], align 2
// LLVM: %[[PREDEC_RESULT:.*]] = fadd half %[[PREDEC_INPUT]], -1.000000e+00
@@ -1106,8 +1106,8 @@ _Float16 Float16UPostInc(_Float16 f) {
}
// CIR: cir.func{{.*}} @_Z15Float16UPostIncDF16_({{.*}}) -> (!cir.f16{{.*}})
-// CIR: %[[POSTINC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f16>
+// CIR: %[[POSTINC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[POSTINC_INPUT:.*]] = cir.load{{.*}} %[[POSTINC_F]]
// CIR: %[[POSTINC_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.f16
// CIR: %[[POSTINC_RESULT:.*]] = cir.fadd %[[POSTINC_INPUT]], %[[POSTINC_ONE]] : !cir.f16
@@ -1117,8 +1117,8 @@ _Float16 Float16UPostInc(_Float16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f16
// LLVM: define{{.*}} half @_Z15Float16UPostIncDF16_({{.*}})
-// LLVM: %[[POSTINC_F_ADDR:.*]] = alloca half, align 2
// LLVM: %[[RV:.*]] = alloca half, align 2
+// LLVM: %[[POSTINC_F_ADDR:.*]] = alloca half, align 2
// LLVM: store half %{{.*}}, ptr %[[POSTINC_F_ADDR]], align 2
// LLVM: %[[POSTINC_INPUT:.*]] = load half, ptr %[[POSTINC_F_ADDR]], align 2
// LLVM: %[[POSTINC_RESULT:.*]] = fadd half %[[POSTINC_INPUT]], 1.000000e+00
@@ -1140,8 +1140,8 @@ _Float16 Float16UPostDec(_Float16 f) {
}
// CIR: cir.func{{.*}} @_Z15Float16UPostDecDF16_({{.*}}) -> (!cir.f16{{.*}})
-// CIR: %[[POSTDEC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.f16>
+// CIR: %[[POSTDEC_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.f16>
// CIR: %[[POSTDEC_INPUT:.*]] = cir.load{{.*}} %[[POSTDEC_F]]
// CIR: %[[POSTDEC_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.f16
// CIR: %[[POSTDEC_RESULT:.*]] = cir.fadd %[[POSTDEC_INPUT]], %[[POSTDEC_NEGONE]] : !cir.f16
@@ -1151,8 +1151,8 @@ _Float16 Float16UPostDec(_Float16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.f16
// LLVM: define{{.*}} half @_Z15Float16UPostDecDF16_({{.*}})
-// LLVM: %[[POSTDEC_F_ADDR:.*]] = alloca half, align 2
// LLVM: %[[RV:.*]] = alloca half, align 2
+// LLVM: %[[POSTDEC_F_ADDR:.*]] = alloca half, align 2
// LLVM: store half %{{.*}}, ptr %[[POSTDEC_F_ADDR]], align 2
// LLVM: %[[POSTDEC_INPUT:.*]] = load half, ptr %[[POSTDEC_F_ADDR]], align 2
// LLVM: %[[POSTDEC_RESULT:.*]] = fadd half %[[POSTDEC_INPUT]], -1.000000e+00
@@ -1444,8 +1444,8 @@ __bf16 bf16UPreInc(__bf16 f) {
}
// CIR: cir.func{{.*}} @_Z11bf16UPreIncDF16b({{.*}}) -> (!cir.bf16{{.*}})
-// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bf16>
+// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[BF16_LOAD:.*]] = cir.load{{.*}} %[[BF16_F]]
// CIR: %[[BF16_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.bf16
// CIR: %[[BF16_INC:.*]] = cir.fadd %[[BF16_LOAD]], %[[BF16_ONE]] : !cir.bf16
@@ -1455,8 +1455,8 @@ __bf16 bf16UPreInc(__bf16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.bf16
// LLVM: define{{.*}} bfloat @_Z11bf16UPreIncDF16b({{.*}})
-// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: %[[RV:.*]] = alloca bfloat, align 2
+// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: store bfloat %{{.*}}, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_LOAD:.*]] = load bfloat, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_INC:.*]] = fadd bfloat %[[BF16_LOAD]], 1.000000e+00
@@ -1478,8 +1478,8 @@ __bf16 bf16UPreDec(__bf16 f) {
}
// CIR: cir.func{{.*}} @_Z11bf16UPreDecDF16b({{.*}}) -> (!cir.bf16{{.*}})
-// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bf16>
+// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[BF16_LOAD:.*]] = cir.load{{.*}} %[[BF16_F]]
// CIR: %[[BF16_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.bf16
// CIR: %[[BF16_DEC:.*]] = cir.fadd %[[BF16_LOAD]], %[[BF16_NEGONE]] : !cir.bf16
@@ -1489,8 +1489,8 @@ __bf16 bf16UPreDec(__bf16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.bf16
// LLVM: define{{.*}} bfloat @_Z11bf16UPreDecDF16b({{.*}})
-// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: %[[RV:.*]] = alloca bfloat, align 2
+// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: store bfloat %{{.*}}, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_LOAD:.*]] = load bfloat, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_DEC:.*]] = fadd bfloat %[[BF16_LOAD]], -1.000000e+00
@@ -1512,8 +1512,8 @@ __bf16 bf16UPostInc(__bf16 f) {
}
// CIR: cir.func{{.*}} @_Z12bf16UPostIncDF16b({{.*}}) -> (!cir.bf16{{.*}})
-// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bf16>
+// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[BF16_LOAD:.*]] = cir.load{{.*}} %[[BF16_F]]
// CIR: %[[BF16_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.bf16
// CIR: %[[BF16_INC:.*]] = cir.fadd %[[BF16_LOAD]], %[[BF16_ONE]] : !cir.bf16
@@ -1523,8 +1523,8 @@ __bf16 bf16UPostInc(__bf16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.bf16
// LLVM: define{{.*}} bfloat @_Z12bf16UPostIncDF16b({{.*}})
-// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: %[[RV:.*]] = alloca bfloat, align 2
+// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: store bfloat %{{.*}}, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_LOAD:.*]] = load bfloat, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_INC:.*]] = fadd bfloat %[[BF16_LOAD]], 1.000000e+00
@@ -1546,8 +1546,8 @@ __bf16 bf16UPostDec(__bf16 f) {
}
// CIR: cir.func{{.*}} @_Z12bf16UPostDecDF16b({{.*}}) -> (!cir.bf16{{.*}})
-// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[RV:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.bf16>
+// CIR: %[[BF16_F:.*]] = cir.alloca "f" {{.*}} init : !cir.ptr<!cir.bf16>
// CIR: %[[BF16_LOAD:.*]] = cir.load{{.*}} %[[BF16_F]]
// CIR: %[[BF16_NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.bf16
// CIR: %[[BF16_DEC:.*]] = cir.fadd %[[BF16_LOAD]], %[[BF16_NEGONE]] : !cir.bf16
@@ -1557,8 +1557,8 @@ __bf16 bf16UPostDec(__bf16 f) {
// CIR: cir.return %[[RV_LOAD]] : !cir.bf16
// LLVM: define{{.*}} bfloat @_Z12bf16UPostDecDF16b({{.*}})
-// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: %[[RV:.*]] = alloca bfloat, align 2
+// LLVM: %[[BF16_F:.*]] = alloca bfloat, align 2
// LLVM: store bfloat %{{.*}}, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_LOAD:.*]] = load bfloat, ptr %[[BF16_F]], align 2
// LLVM: %[[BF16_DEC:.*]] = fadd bfloat %[[BF16_LOAD]], -1.000000e+00
@@ -1744,8 +1744,8 @@ vi4 vecIntPreInc(vi4 a) {
return ++a;
}
// CIR-LABEL: @_Z12vecIntPreIncDv4_i
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[INCREMENTED:.+]] = cir.inc %[[INPUT]] : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[INCREMENTED]], %[[A]]
@@ -1754,8 +1754,8 @@ vi4 vecIntPreInc(vi4 a) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !s32i>
// LLVM-LABEL: @_Z12vecIntPreIncDv4_i
-// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[A]], align 16
// LLVM: %[[INCREMENTED:.+]] = add <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1775,8 +1775,8 @@ vi4 vecIntPreDec(vi4 a) {
return --a;
}
// CIR-LABEL: @_Z12vecIntPreDecDv4_i
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[DECREMENTED:.+]] = cir.dec %[[INPUT]] : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[DECREMENTED]], %[[A]]
@@ -1785,8 +1785,8 @@ vi4 vecIntPreDec(vi4 a) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !s32i>
// LLVM-LABEL: @_Z12vecIntPreDecDv4_i
-// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[A]], align 16
// LLVM: %[[DECREMENTED:.+]] = sub <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1806,8 +1806,8 @@ vi4 vecIntPostInc(vi4 a) {
return a++;
}
// CIR-LABEL: @_Z13vecIntPostIncDv4_i
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[INCREMENTED:.+]] = cir.inc %[[INPUT]] : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[INCREMENTED]], %[[A]]
@@ -1816,8 +1816,8 @@ vi4 vecIntPostInc(vi4 a) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !s32i>
// LLVM-LABEL: @_Z13vecIntPostIncDv4_i
-// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[A]], align 16
// LLVM: %[[INCREMENTED:.+]] = add <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1837,8 +1837,8 @@ vi4 vecIntPostDec(vi4 a) {
return a--;
}
// CIR-LABEL: @_Z13vecIntPostDecDv4_i
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s32i>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[DECREMENTED:.+]] = cir.dec %[[INPUT]] : !cir.vector<4 x !s32i>
// CIR: cir.store{{.*}} %[[DECREMENTED]], %[[A]]
@@ -1847,8 +1847,8 @@ vi4 vecIntPostDec(vi4 a) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !s32i>
// LLVM-LABEL: @_Z13vecIntPostDecDv4_i
-// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[A]], align 16
// LLVM: %[[DECREMENTED:.+]] = sub <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1868,8 +1868,8 @@ uvi4 vecUIntPreInc(uvi4 b) {
return ++b;
}
// CIR-LABEL: @_Z13vecUIntPreIncDv4_j
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[INCREMENTED:.+]] = cir.inc %[[INPUT]] : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[INCREMENTED]], %[[B]]
@@ -1878,8 +1878,8 @@ uvi4 vecUIntPreInc(uvi4 b) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !u32i>
// LLVM-LABEL: @_Z13vecUIntPreIncDv4_j
-// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[B]], align 16
// LLVM: %[[INCREMENTED:.+]] = add <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1899,8 +1899,8 @@ uvi4 vecUIntPreDec(uvi4 b) {
return --b;
}
// CIR-LABEL: @_Z13vecUIntPreDecDv4_j
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[DECREMENTED:.+]] = cir.dec %[[INPUT]] : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[DECREMENTED]], %[[B]]
@@ -1909,8 +1909,8 @@ uvi4 vecUIntPreDec(uvi4 b) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !u32i>
// LLVM-LABEL: @_Z13vecUIntPreDecDv4_j
-// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[B]], align 16
// LLVM: %[[DECREMENTED:.+]] = sub <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1930,8 +1930,8 @@ uvi4 vecUIntPostInc(uvi4 b) {
return b++;
}
// CIR-LABEL: @_Z14vecUIntPostIncDv4_j
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[INCREMENTED:.+]] = cir.inc %[[INPUT]] : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[INCREMENTED]], %[[B]]
@@ -1940,8 +1940,8 @@ uvi4 vecUIntPostInc(uvi4 b) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !u32i>
// LLVM-LABEL: @_Z14vecUIntPostIncDv4_j
-// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[B]], align 16
// LLVM: %[[INCREMENTED:.+]] = add <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1961,8 +1961,8 @@ uvi4 vecUIntPostDec(uvi4 b) {
return b--;
}
// CIR-LABEL: @_Z14vecUIntPostDecDv4_j
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !u32i>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !u32i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[DECREMENTED:.+]] = cir.dec %[[INPUT]] : !cir.vector<4 x !u32i>
// CIR: cir.store{{.*}} %[[DECREMENTED]], %[[B]]
@@ -1971,8 +1971,8 @@ uvi4 vecUIntPostDec(uvi4 b) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<4 x !u32i>
// LLVM-LABEL: @_Z14vecUIntPostDecDv4_j
-// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x i32>, align 16
+// LLVM: %[[B:.+]] = alloca <4 x i32>, align 16
// LLVM: store <4 x i32> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x i32>, ptr %[[B]], align 16
// LLVM: %[[DECREMENTED:.+]] = sub <4 x i32> %[[INPUT]], splat (i32 1)
@@ -1992,8 +1992,8 @@ vsh8 vecShortPreInc(vsh8 c) {
return ++c;
}
// CIR-LABEL: @_Z14vecShortPreIncDv8_s
-// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<8 x !s16i>>
+// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[C]]
// CIR: %[[INCREMENTED:.+]] = cir.inc %[[INPUT]] : !cir.vector<8 x !s16i>
// CIR: cir.store{{.*}} %[[INCREMENTED]], %[[C]]
@@ -2002,8 +2002,8 @@ vsh8 vecShortPreInc(vsh8 c) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<8 x !s16i>
// LLVM-LABEL: @_Z14vecShortPreIncDv8_s
-// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <8 x i16>, align 16
+// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: store <8 x i16> %{{.+}}, ptr %[[C]], align 16
// LLVM: %[[INPUT:.+]] = load <8 x i16>, ptr %[[C]], align 16
// LLVM: %[[INCREMENTED:.+]] = add <8 x i16> %[[INPUT]], splat (i16 1)
@@ -2023,8 +2023,8 @@ vsh8 vecShortPreDec(vsh8 c) {
return --c;
}
// CIR-LABEL: @_Z14vecShortPreDecDv8_s
-// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<8 x !s16i>>
+// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[C]]
// CIR: %[[DECREMENTED:.+]] = cir.dec %[[INPUT]] : !cir.vector<8 x !s16i>
// CIR: cir.store{{.*}} %[[DECREMENTED]], %[[C]]
@@ -2033,8 +2033,8 @@ vsh8 vecShortPreDec(vsh8 c) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<8 x !s16i>
// LLVM-LABEL: @_Z14vecShortPreDecDv8_s
-// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <8 x i16>, align 16
+// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: store <8 x i16> %{{.+}}, ptr %[[C]], align 16
// LLVM: %[[INPUT:.+]] = load <8 x i16>, ptr %[[C]], align 16
// LLVM: %[[DECREMENTED:.+]] = sub <8 x i16> %[[INPUT]], splat (i16 1)
@@ -2054,8 +2054,8 @@ vsh8 vecShortPostInc(vsh8 c) {
return c++;
}
// CIR-LABEL: @_Z15vecShortPostIncDv8_s
-// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<8 x !s16i>>
+// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[C]]
// CIR: %[[INCREMENTED:.+]] = cir.inc %[[INPUT]] : !cir.vector<8 x !s16i>
// CIR: cir.store{{.*}} %[[INCREMENTED]], %[[C]]
@@ -2064,8 +2064,8 @@ vsh8 vecShortPostInc(vsh8 c) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<8 x !s16i>
// LLVM-LABEL: @_Z15vecShortPostIncDv8_s
-// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <8 x i16>, align 16
+// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: store <8 x i16> %{{.+}}, ptr %[[C]], align 16
// LLVM: %[[INPUT:.+]] = load <8 x i16>, ptr %[[C]], align 16
// LLVM: %[[INCREMENTED:.+]] = add <8 x i16> %[[INPUT]], splat (i16 1)
@@ -2085,8 +2085,8 @@ vsh8 vecShortPostDec(vsh8 c) {
return c--;
}
// CIR-LABEL: @_Z15vecShortPostDecDv8_s
-// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[RV:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<8 x !s16i>>
+// CIR: %[[C:.+]] = cir.alloca "c" {{.*}} init : !cir.ptr<!cir.vector<8 x !s16i>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[C]]
// CIR: %[[DECREMENTED:.+]] = cir.dec %[[INPUT]] : !cir.vector<8 x !s16i>
// CIR: cir.store{{.*}} %[[DECREMENTED]], %[[C]]
@@ -2095,8 +2095,8 @@ vsh8 vecShortPostDec(vsh8 c) {
// CIR: cir.return %[[RV_LOAD]] : !cir.vector<8 x !s16i>
// LLVM-LABEL: @_Z15vecShortPostDecDv8_s
-// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <8 x i16>, align 16
+// LLVM: %[[C:.+]] = alloca <8 x i16>, align 16
// LLVM: store <8 x i16> %{{.+}}, ptr %[[C]], align 16
// LLVM: %[[INPUT:.+]] = load <8 x i16>, ptr %[[C]], align 16
// LLVM: %[[DECREMENTED:.+]] = sub <8 x i16> %[[INPUT]], splat (i16 1)
@@ -2116,8 +2116,8 @@ vf4 vecFloatPreInc(vf4 a) {
return ++a;
}
// CIR-LABEL: @_Z14vecFloatPreIncDv4_f
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CIR: %[[ONEVEC:.*]] = cir.vec.splat %[[ONE]] : !cir.float, !cir.vector<4 x !cir.float>
@@ -2128,8 +2128,8 @@ vf4 vecFloatPreInc(vf4 a) {
// CIR: cir.return %[[RV]] : !cir.vector<4 x !cir.float>
// LLVM-LABEL: @_Z14vecFloatPreIncDv4_f
-// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x float>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: store <4 x float> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x float>, ptr %[[A]], align 16
// LLVM: %[[INCREMENTED:.+]] = fadd <4 x float> %[[INPUT]], splat (float 1.000000e+00)
@@ -2149,8 +2149,8 @@ vf4 vecFloatPreDec(vf4 a) {
return --a;
}
// CIR-LABEL: @_Z14vecFloatPreDecDv4_f
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.float
// CIR: %[[NEGONEVEC:.*]] = cir.vec.splat %[[NEGONE]] : !cir.float, !cir.vector<4 x !cir.float>
@@ -2161,8 +2161,8 @@ vf4 vecFloatPreDec(vf4 a) {
// CIR: cir.return %[[RV]] : !cir.vector<4 x !cir.float>
// LLVM-LABEL: @_Z14vecFloatPreDecDv4_f
-// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x float>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: store <4 x float> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x float>, ptr %[[A]], align 16
// LLVM: %[[DECREMENTED:.+]] = fadd <4 x float> %[[INPUT]], splat (float -1.000000e+00)
@@ -2182,8 +2182,8 @@ vf4 vecFloatPostInc(vf4 a) {
return a++;
}
// CIR-LABEL: @_Z15vecFloatPostIncDv4_f
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
// CIR: %[[ONEVEC:.*]] = cir.vec.splat %[[ONE]] : !cir.float, !cir.vector<4 x !cir.float>
@@ -2194,8 +2194,8 @@ vf4 vecFloatPostInc(vf4 a) {
// CIR: cir.return %[[RV]] : !cir.vector<4 x !cir.float>
// LLVM-LABEL: @_Z15vecFloatPostIncDv4_f
-// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x float>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: store <4 x float> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x float>, ptr %[[A]], align 16
// LLVM: %[[INCREMENTED:.+]] = fadd <4 x float> %[[INPUT]], splat (float 1.000000e+00)
@@ -2215,8 +2215,8 @@ vf4 vecFloatPostDec(vf4 a) {
return a--;
}
// CIR-LABEL: @_Z15vecFloatPostDecDv4_f
-// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !cir.float>>
+// CIR: %[[A:.+]] = cir.alloca "a" {{.*}} init : !cir.ptr<!cir.vector<4 x !cir.float>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[A]]
// CIR: %[[NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.float
// CIR: %[[NEGONEVEC:.*]] = cir.vec.splat %[[NEGONE]] : !cir.float, !cir.vector<4 x !cir.float>
@@ -2227,8 +2227,8 @@ vf4 vecFloatPostDec(vf4 a) {
// CIR: cir.return %[[RV]] : !cir.vector<4 x !cir.float>
// LLVM-LABEL: @_Z15vecFloatPostDecDv4_f
-// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <4 x float>, align 16
+// LLVM: %[[A:.+]] = alloca <4 x float>, align 16
// LLVM: store <4 x float> %{{.+}}, ptr %[[A]], align 16
// LLVM: %[[INPUT:.+]] = load <4 x float>, ptr %[[A]], align 16
// LLVM: %[[DECREMENTED:.+]] = fadd <4 x float> %[[INPUT]], splat (float -1.000000e+00)
@@ -2248,8 +2248,8 @@ vd2 vecDoublePreInc(vd2 b) {
return ++b;
}
// CIR-LABEL: @_Z15vecDoublePreIncDv2_d
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.double
// CIR: %[[ONEVEC:.*]] = cir.vec.splat %[[ONE]] : !cir.double, !cir.vector<2 x !cir.double>
@@ -2260,8 +2260,8 @@ vd2 vecDoublePreInc(vd2 b) {
// CIR: cir.return %[[RV]] : !cir.vector<2 x !cir.double>
// LLVM-LABEL: @_Z15vecDoublePreIncDv2_d
-// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <2 x double>, align 16
+// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: store <2 x double> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <2 x double>, ptr %[[B]], align 16
// LLVM: %[[INCREMENTED:.+]] = fadd <2 x double> %[[INPUT]], splat (double 1.000000e+00)
@@ -2281,8 +2281,8 @@ vd2 vecDoublePreDec(vd2 b) {
return --b;
}
// CIR-LABEL: @_Z15vecDoublePreDecDv2_d
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.double
// CIR: %[[NEGONEVEC:.*]] = cir.vec.splat %[[NEGONE]] : !cir.double, !cir.vector<2 x !cir.double>
@@ -2293,8 +2293,8 @@ vd2 vecDoublePreDec(vd2 b) {
// CIR: cir.return %[[RV]] : !cir.vector<2 x !cir.double>
// LLVM-LABEL: @_Z15vecDoublePreDecDv2_d
-// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <2 x double>, align 16
+// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: store <2 x double> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <2 x double>, ptr %[[B]], align 16
// LLVM: %[[DECREMENTED:.+]] = fadd <2 x double> %[[INPUT]], splat (double -1.000000e+00)
@@ -2314,8 +2314,8 @@ vd2 vecDoublePostInc(vd2 b) {
return b++;
}
// CIR-LABEL: @_Z16vecDoublePostIncDv2_d
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.double
// CIR: %[[ONEVEC:.*]] = cir.vec.splat %[[ONE]] : !cir.double, !cir.vector<2 x !cir.double>
@@ -2326,8 +2326,8 @@ vd2 vecDoublePostInc(vd2 b) {
// CIR: cir.return %[[RV]] : !cir.vector<2 x !cir.double>
// LLVM-LABEL: @_Z16vecDoublePostIncDv2_d
-// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <2 x double>, align 16
+// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: store <2 x double> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <2 x double>, ptr %[[B]], align 16
// LLVM: %[[INCREMENTED:.+]] = fadd <2 x double> %[[INPUT]], splat (double 1.000000e+00)
@@ -2347,8 +2347,8 @@ vd2 vecDoublePostDec(vd2 b) {
return b--;
}
// CIR-LABEL: @_Z16vecDoublePostDecDv2_d
-// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[RVPTR:.+]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<2 x !cir.double>>
+// CIR: %[[B:.+]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<2 x !cir.double>>
// CIR: %[[INPUT:.+]] = cir.load{{.*}} %[[B]]
// CIR: %[[NEGONE:.*]] = cir.const #cir.fp<-1.000000e+00> : !cir.double
// CIR: %[[NEGONEVEC:.*]] = cir.vec.splat %[[NEGONE]] : !cir.double, !cir.vector<2 x !cir.double>
@@ -2359,8 +2359,8 @@ vd2 vecDoublePostDec(vd2 b) {
// CIR: cir.return %[[RV]] : !cir.vector<2 x !cir.double>
// LLVM-LABEL: @_Z16vecDoublePostDecDv2_d
-// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: %[[RVPTR:.+]] = alloca <2 x double>, align 16
+// LLVM: %[[B:.+]] = alloca <2 x double>, align 16
// LLVM: store <2 x double> %{{.+}}, ptr %[[B]], align 16
// LLVM: %[[INPUT:.+]] = load <2 x double>, ptr %[[B]], align 16
// LLVM: %[[DECREMENTED:.+]] = fadd <2 x double> %[[INPUT]], splat (double -1.000000e+00)
diff --git a/clang/test/CIR/CodeGen/var_arg.c b/clang/test/CIR/CodeGen/var_arg.c
index 8fee819bd8e796..a54cf025b9158b 100644
--- a/clang/test/CIR/CodeGen/var_arg.c
+++ b/clang/test/CIR/CodeGen/var_arg.c
@@ -59,6 +59,7 @@ int varargs(int count, ...) {
// CIR: cir.return %[[RETVAL]] : !s32i
// LLVM-LABEL: define dso_local i32 @varargs(i32 noundef %{{.+}}, ...)
+// LLVMCIR: %[[RET_ADDR:.+]] = alloca i32{{.*}}, align 4
// LLVM: %[[COUNT_ADDR:.+]] = alloca i32{{.*}}, align 4
// LLVM: %[[VAAREA:.+]] = alloca [1 x %struct.__va_list_tag]{{.*}}, align 16
// LLVM: %[[RES_ADDR:.+]] = alloca i32{{.*}}, align 4
@@ -108,6 +109,7 @@ int stdarg_start(int count, ...) {
// CIR: cir.return %[[RETVAL]] : !s32i
// LLVM-LABEL: define dso_local i32 @stdarg_start(i32 noundef %{{.+}}, ...)
+// LLVMCIR: %[[RET_ADDR:.+]] = alloca i32{{.*}}, align 4
// LLVM: %[[COUNT_ADDR:.+]] = alloca i32{{.*}}, align 4
// LLVM: %[[VAAREA:.+]] = alloca [1 x %struct.__va_list_tag]{{.*}}, align 16
// LLVM: %[[RES_ADDR:.+]] = alloca i32{{.*}}, align 4
@@ -176,6 +178,7 @@ int varargs_new(char *fmt, ...) {
// CIR: cir.return %[[RETVAL]] : !s32i
// LLVM-LABEL: define dso_local i32 @varargs_new(ptr noundef %{{.+}}, ...)
+// LLVMCIR: %[[RET_ADDR:.+]] = alloca i32{{.*}}, align 4
// LLVM: %[[FMT_ADDR:.+]] = alloca ptr{{.*}}, align 8
// LLVM: %[[VAAREA:.+]] = alloca [1 x %struct.__va_list_tag]{{.*}}, align 16
// LLVM: %[[RES_ADDR:.+]] = alloca i32{{.*}}, align 4
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index 6ec3b6f22a159b..db1d58415d092f 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -232,10 +232,10 @@ void f3(unsigned len) {
// CIR: cir.stackrestore %[[STACK_RESTORE_PTR]]
// LLVM: define{{.*}} void @f3(i32 {{.*}} %[[LEN_ARG:.*]])
-// LLVM: %[[SAVED_STACK2:.*]] = alloca ptr
// LLVM: %[[LEN_ADDR:.*]] = alloca i32
// LLVM: %[[SAVED_STACK:.*]] = alloca ptr
// LLVM: %[[I:.*]] = alloca i32
+// LLVM: %[[SAVED_STACK2:.*]] = alloca ptr
// LLVM: store i32 %[[LEN_ARG]], ptr %[[LEN_ADDR]]
// LLVM: %[[LEN:.*]] = load i32, ptr %[[LEN_ADDR]]
// LLVM: %[[LEN_SIZE_T:.*]] = zext i32 %[[LEN]] to i64
@@ -329,8 +329,8 @@ int f5(unsigned long len) {
}
// CIR: cir.func{{.*}} @f5(%[[LEN_ARG:.*]]: !u64i {{.*}}) -> !s32i
-// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!u64i>
// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[LEN_ADDR:.*]] = cir.alloca "len" {{.*}} init : !cir.ptr<!u64i>
// 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]]
@@ -347,8 +347,9 @@ int f5(unsigned long len) {
// CIR: cir.return %[[RET_VAL]] : !s32i
// LLVM: define{{.*}} i32 @f5(i64 {{.*}} %[[LEN_ARG:.*]])
-// LLVM: %[[LEN_ADDR:.*]] = alloca i64
+// LLVM: %[[CLEANUP_DEST:.*]] = alloca i32
// LLVM: %[[RET_ADDR:.*]] = alloca i32
+// LLVM: %[[LEN_ADDR:.*]] = alloca i64
// LLVM: %[[SAVED_STACK:.*]] = alloca ptr
// LLVM: store i64 %[[LEN_ARG]], ptr %[[LEN_ADDR]]
// LLVM: %[[LEN:.*]] = load i64, ptr %[[LEN_ADDR]]
diff --git a/clang/test/CIR/CodeGenBuiltins/X86/avx-shuffle-builtins.c b/clang/test/CIR/CodeGenBuiltins/X86/avx-shuffle-builtins.c
index 1e12a95e0f408c..8e6b843975a53b 100644
--- a/clang/test/CIR/CodeGenBuiltins/X86/avx-shuffle-builtins.c
+++ b/clang/test/CIR/CodeGenBuiltins/X86/avx-shuffle-builtins.c
@@ -17,8 +17,8 @@
__m256d test0_mm256_insertf128_pd(__m256d a, __m128d b) {
// CIR-LABEL: @test0_mm256_insertf128_pd(
- // CIR: [[A:%.*]] = cir.load align(32) %0 : !cir.ptr<!cir.vector<4 x !cir.double>>, !cir.vector<4 x !cir.double>
- // CIR: [[B:%.*]] = cir.load align(16) %1 : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
+ // CIR: [[A:%.*]] = cir.load align(32) %1 : !cir.ptr<!cir.vector<4 x !cir.double>>, !cir.vector<4 x !cir.double>
+ // CIR: [[B:%.*]] = cir.load align(16) %2 : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
// CIR: %{{.*}} = cir.vec.shuffle([[B]], %{{.*}} : !cir.vector<2 x !cir.double>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<4 x !cir.double>
// CIR-NEXT: %{{.*}} = cir.vec.shuffle([[A]], %{{.*}} : !s32i, #cir.int<5> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<4 x !cir.double>
// CIR: cir.return %{{.*}} : !cir.vector<4 x !cir.double>
@@ -41,8 +41,8 @@ __m256d test0_mm256_insertf128_pd(__m256d a, __m128d b) {
__m256d test1_mm256_insertf128_pd(__m256d a, __m128d b) {
// CIR-LABEL: @test1_mm256_insertf128_pd(
- // CIR: [[A:%.*]] = cir.load align(32) %0 : !cir.ptr<!cir.vector<4 x !cir.double>>, !cir.vector<4 x !cir.double>
- // CIR: [[B:%.*]] = cir.load align(16) %1 : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
+ // CIR: [[A:%.*]] = cir.load align(32) %1 : !cir.ptr<!cir.vector<4 x !cir.double>>, !cir.vector<4 x !cir.double>
+ // CIR: [[B:%.*]] = cir.load align(16) %2 : !cir.ptr<!cir.vector<2 x !cir.double>>, !cir.vector<2 x !cir.double>
// CIR: %{{.*}} = cir.vec.shuffle([[B]], %{{.*}} : !cir.vector<2 x !cir.double>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i] : !cir.vector<4 x !cir.double>
// CIR-NEXT: %{{.*}} = cir.vec.shuffle([[A]], %{{.*}} : !cir.vector<4 x !cir.double>) [#cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<4> : !s32i, #cir.int<5> : !s32i] : !cir.vector<4 x !cir.double>
// CIR: cir.return %{{.*}} : !cir.vector<4 x !cir.double>
diff --git a/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c b/clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c
index 59ce82c7bd77c1..204c0d8d3d84c7 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_2:.*]] = cir.alloca "__retval" align(16) : !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>
@@ -28,9 +28,9 @@ __m128 test_cmpnleps(__m128 A, __m128 B) {
// LLVM-LABEL: define dso_local <4 x float> @test_cmpnleps(
// LLVM-SAME: <4 x float> noundef [[TMP0:%.*]], <4 x float> noundef [[TMP1:%.*]]) #{{[0-9]+}} {
+ // LLVM-NEXT: [[TMP5:%.*]] = alloca <4 x float>, align 16
// LLVM-NEXT: [[TMP3:%.*]] = alloca <4 x float>, align 16
// LLVM-NEXT: [[TMP4:%.*]] = alloca <4 x float>, align 16
- // LLVM-NEXT: [[TMP5:%.*]] = alloca <4 x float>, align 16
// LLVM-NEXT: store <4 x float> [[TMP0]], ptr [[TMP3]], align 16
// LLVM-NEXT: store <4 x float> [[TMP1]], ptr [[TMP4]], align 16
// LLVM-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[TMP3]], align 16
@@ -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_2:.*]] = cir.alloca "__retval" align(16) : !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>
@@ -79,9 +79,9 @@ __m128d test_cmpnlepd(__m128d A, __m128d B) {
// LLVM-LABEL: define dso_local <2 x double> @test_cmpnlepd(
// LLVM-SAME: <2 x double> noundef [[TMP0:%.*]], <2 x double> noundef [[TMP1:%.*]]) #{{[0-9]+}} {
+ // LLVM-NEXT: [[TMP5:%.*]] = alloca <2 x double>, align 16
// LLVM-NEXT: [[TMP3:%.*]] = alloca <2 x double>, align 16
// LLVM-NEXT: [[TMP4:%.*]] = alloca <2 x double>, align 16
- // LLVM-NEXT: [[TMP5:%.*]] = alloca <2 x double>, align 16
// LLVM-NEXT: store <2 x double> [[TMP0]], ptr [[TMP3]], align 16
// LLVM-NEXT: store <2 x double> [[TMP1]], ptr [[TMP4]], align 16
// LLVM-NEXT: [[TMP6:%.*]] = load <2 x double>, ptr [[TMP3]], align 16
@@ -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_2:.*]] = cir.alloca "__retval" align(16) : !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>
@@ -130,9 +130,9 @@ __m128 test_cmpnltps(__m128 A, __m128 B) {
// LLVM-LABEL: define dso_local <4 x float> @test_cmpnltps(
// LLVM-SAME: <4 x float> noundef [[TMP0:%.*]], <4 x float> noundef [[TMP1:%.*]]) #{{[0-9]+}} {
+ // LLVM-NEXT: [[TMP5:%.*]] = alloca <4 x float>, align 16
// LLVM-NEXT: [[TMP3:%.*]] = alloca <4 x float>, align 16
// LLVM-NEXT: [[TMP4:%.*]] = alloca <4 x float>, align 16
- // LLVM-NEXT: [[TMP5:%.*]] = alloca <4 x float>, align 16
// LLVM-NEXT: store <4 x float> [[TMP0]], ptr [[TMP3]], align 16
// LLVM-NEXT: store <4 x float> [[TMP1]], ptr [[TMP4]], align 16
// LLVM-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[TMP3]], align 16
@@ -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_2:.*]] = cir.alloca "__retval" align(16) : !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>
@@ -181,9 +181,9 @@ __m128d test_cmpnltpd(__m128d A, __m128d B) {
// LLVM-LABEL: define dso_local <2 x double> @test_cmpnltpd(
// LLVM-SAME: <2 x double> noundef [[TMP0:%.*]], <2 x double> noundef [[TMP1:%.*]]) #{{[0-9]+}} {
+ // LLVM-NEXT: [[TMP5:%.*]] = alloca <2 x double>, align 16
// LLVM-NEXT: [[TMP3:%.*]] = alloca <2 x double>, align 16
// LLVM-NEXT: [[TMP4:%.*]] = alloca <2 x double>, align 16
- // LLVM-NEXT: [[TMP5:%.*]] = alloca <2 x double>, align 16
// LLVM-NEXT: store <2 x double> [[TMP0]], ptr [[TMP3]], align 16
// LLVM-NEXT: store <2 x double> [[TMP1]], ptr [[TMP4]], align 16
// LLVM-NEXT: [[TMP6:%.*]] = load <2 x double>, ptr [[TMP3]], align 16
diff --git a/clang/test/CIR/CodeGenCoroutines/coro-task.cpp b/clang/test/CIR/CodeGenCoroutines/coro-task.cpp
index 694815bffafecb..b0970c5cc6d590 100644
--- a/clang/test/CIR/CodeGenCoroutines/coro-task.cpp
+++ b/clang/test/CIR/CodeGenCoroutines/coro-task.cpp
@@ -238,8 +238,8 @@ folly::coro::Task<int> byRef(const std::string& s) {
}
// CIR: cir.func coroutine {{.*}} @_Z5byRefRKSt6string(%[[ARG:.*]]: !cir.ptr<![[StdString]]> {{.*}}) attributes
-// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<![[StdString]]>>
// CIR: %[[IntTaskAddr:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<![[IntTask]]>
+// CIR: %[[AllocaParam:.*]] = cir.alloca "s" {{.*}} init const : !cir.ptr<!cir.ptr<![[StdString]]>>
// 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]]>
diff --git a/clang/test/CIR/CodeGenOpenCL/as_type.cl b/clang/test/CIR/CodeGenOpenCL/as_type.cl
index 303ebebc1f2589..5d1acb98719ded 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 : !cir.ptr<!s32i>
// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.vector<4 x !s8i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !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_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.ptr<!cir.vector<4 x !s8i>>
// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!s32i>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.vector<4 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: %[[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 : !cir.ptr<!s32i>
// CIR: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !cir.ptr<!cir.ptr<!s32i>>
+// CIR: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !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>
@@ -69,8 +69,8 @@ char3 vec4_to_vec_3(char4 x) {
}
// CIR: cir.func {{.*}} @vec4_to_vec_3
-// 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: %[[X_ADDR:.*]] = cir.alloca "x" {{.*}} init : !cir.ptr<!cir.vector<4 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/CodeGenOpenCL/vector.cl b/clang/test/CIR/CodeGenOpenCL/vector.cl
index 4013449cb49b2b..d37bd6b4a19294 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: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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: %[[RET_ADDR:.*]] = cir.alloca "__retval" {{.*}} : !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>>
@@ -76,8 +76,8 @@ int4 vec_unary_inc(int4 a) {
return a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !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" {{.*}} init : !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: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[VEC_INC:.*]] = cir.inc %[[TMP_A]] : !cir.vector<4 x !s32i>
@@ -93,8 +93,8 @@ int4 vec_unary_dec(int4 a) {
return a;
}
-// CIR: %[[A_ADDR:.*]] = cir.alloca "a" {{.*}} init : !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" {{.*}} init : !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: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !s32i>>, !cir.vector<4 x !s32i>
// CIR: %[[VEC_DEC:.*]] = cir.dec %[[TMP_A]] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/Lowering/basic.cpp b/clang/test/CIR/Lowering/basic.cpp
index 606fe1c3e6d8dc..4ccebb554bd805 100644
--- a/clang/test/CIR/Lowering/basic.cpp
+++ b/clang/test/CIR/Lowering/basic.cpp
@@ -32,8 +32,8 @@ int f3(int i) {
}
// CHECK: define{{.*}} i32 @_Z2f3i(i32 noundef %[[ARG:.*]])
-// CHECK: %[[ARG_ALLOCA:.*]] = alloca i32, align 4
// CHECK: %[[RV:.*]] = alloca i32, align 4
+// CHECK: %[[ARG_ALLOCA:.*]] = alloca i32, align 4
// CHECK: store i32 %[[ARG]], ptr %[[ARG_ALLOCA]], align 4
// CHECK: %[[ARG_VAL:.*]] = load i32, ptr %[[ARG_ALLOCA]], align 4
// CHECK: store i32 %[[ARG_VAL]], ptr %[[RV]], align 4
@@ -45,8 +45,8 @@ int f4(const int i) {
}
// CHECK: define{{.*}} i32 @_Z2f4i(i32 noundef %[[ARG:.*]])
-// CHECK: %[[ARG_ALLOCA:.*]] = alloca i32, align 4
// CHECK: %[[RV:.*]] = alloca i32, align 4
+// CHECK: %[[ARG_ALLOCA:.*]] = alloca i32, align 4
// CHECK: store i32 %[[ARG]], ptr %[[ARG_ALLOCA]], align 4
// CHECK: %[[ARG_VAL:.*]] = load i32, ptr %[[ARG_ALLOCA]], align 4
// CHECK: store i32 %[[ARG_VAL]], ptr %[[RV]], align 4
diff --git a/clang/test/CIR/Transforms/hoist-allocas.cir b/clang/test/CIR/Transforms/hoist-allocas.cir
index 222be921b3a170..acedfd07b46986 100644
--- a/clang/test/CIR/Transforms/hoist-allocas.cir
+++ b/clang/test/CIR/Transforms/hoist-allocas.cir
@@ -223,3 +223,54 @@ cir.func @alloca_after_straightline() {
// CHECK-NEXT: cir.const
// CHECK-NEXT: cir.store
// CHECK-NEXT: cir.alloca{{.*}}"second"
+
+cir.func @hoist_after_entry_allocas() {
+ %0 = cir.alloca "first" align(4) init : !cir.ptr<!s32i>
+ %1 = cir.alloca "second" align(4) init : !cir.ptr<!s32i>
+ cir.scope {
+ %2 = cir.alloca "inner" align(4) init : !cir.ptr<!s32i>
+ cir.scope {
+ %3 = cir.alloca "nested" align(4) init : !cir.ptr<!s32i>
+ }
+ }
+ cir.return
+}
+
+// CHECK: cir.func{{.*}} @hoist_after_entry_allocas()
+// CHECK-NEXT: cir.alloca{{.*}}"first"
+// CHECK-NEXT: cir.alloca{{.*}}"second"
+// CHECK-NEXT: cir.alloca{{.*}}"inner"
+// CHECK-NEXT: cir.alloca{{.*}}"nested"
+// CHECK-NEXT: cir.scope
+
+cir.func @entry_alloca_after_scope() {
+ %0 = cir.alloca "first" align(4) init : !cir.ptr<!s32i>
+ cir.scope {
+ %1 = cir.alloca "inner" align(4) init : !cir.ptr<!s32i>
+ }
+ %2 = cir.alloca "after" align(4) init : !cir.ptr<!s32i>
+ cir.return
+}
+
+// CHECK: cir.func{{.*}} @entry_alloca_after_scope()
+// CHECK-NEXT: cir.alloca{{.*}}"first"
+// CHECK-NEXT: cir.alloca{{.*}}"inner"
+// CHECK-NEXT: cir.alloca{{.*}}"after"
+// CHECK-NEXT: cir.scope
+
+cir.func @omp_region_leading_alloca() {
+ omp.parallel {
+ %0 = cir.alloca "first" align(4) init : !cir.ptr<!s32i>
+ cir.scope {
+ %1 = cir.alloca "inner" align(4) init : !cir.ptr<!s32i>
+ }
+ omp.terminator
+ }
+ cir.return
+}
+
+// CHECK: cir.func{{.*}} @omp_region_leading_alloca()
+// CHECK-NEXT: omp.parallel {
+// CHECK-NEXT: cir.alloca{{.*}}"first"
+// CHECK-NEXT: cir.alloca{{.*}}"inner"
+// CHECK-NEXT: cir.scope
>From 883d9904fef3e0b5486db63eac4cbbfb8ea9b522 Mon Sep 17 00:00:00 2001
From: Adam Smith <adams at nvidia.com>
Date: Wed, 14 Oct 2026 11:37:42 -0700
Subject: [PATCH 2/4] [CIR] Address reviewer feedback
Assisted-by: Cursor / claude-opus-5.5
---
clang/lib/CIR/CodeGen/CIRGenFunction.cpp | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
index 1b040de149e714..fbf86985a42dca 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
@@ -559,8 +559,9 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
// When the current function is not void, create an address to store the
// result value.
if (!returnType->isVoidType()) {
- // Determine the function body end location.
- // If fd is null or has no body, use loc as fallback.
+ // Determine the function body end location. A function without a body
+ // uses its declaration's location, as classic codegen does, and a null fd
+ // uses loc.
SourceLocation bodyEndLoc = loc;
if (fd) {
if (Stmt *body = fd->getBody())
@@ -578,8 +579,9 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
emitStartEHSpec(d);
prologueCleanupDepth = ehStack.stable_begin();
- // Determine the function body begin location for the prolog.
- // If fd is null or has no body, use startLoc as fallback.
+ // Determine the function body begin location for the prolog. A function
+ // without a body uses its declaration's location, as classic codegen does,
+ // and a null fd uses startLoc.
SourceLocation bodyBeginLoc = startLoc;
if (fd) {
if (Stmt *body = fd->getBody())
>From 6e945c95350d540788bc5acf0984510eef0ff56a Mon Sep 17 00:00:00 2001
From: Adam Smith <adams at nvidia.com>
Date: Wed, 14 Oct 2026 20:26:49 -0500
Subject: [PATCH 3/4] Update clang/lib/CIR/CodeGen/CIRGenFunction.cpp
Co-authored-by: Andy Kaylor <akaylor at nvidia.com>
---
clang/lib/CIR/CodeGen/CIRGenFunction.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
index fbf86985a42dca..fbbfe698c87503 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
@@ -560,7 +560,7 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
// result value.
if (!returnType->isVoidType()) {
// Determine the function body end location. A function without a body
- // uses its declaration's location, as classic codegen does, and a null fd
+ // uses its declaration's location, and a null fd
// uses loc.
SourceLocation bodyEndLoc = loc;
if (fd) {
>From b448b6fdf1c34e206f81fa238799b6c5645d7a7e Mon Sep 17 00:00:00 2001
From: Adam Smith <adams at nvidia.com>
Date: Wed, 14 Oct 2026 18:33:51 -0700
Subject: [PATCH 4/4] [CIR] Address reviewer feedback
Assisted-by: Cursor / claude-opus-5.5
---
clang/lib/CIR/CodeGen/CIRGenFunction.cpp | 7 +++----
clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp | 2 +-
2 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
index fbbfe698c87503..14fc9cdff3ab6c 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.cpp
@@ -560,8 +560,7 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
// result value.
if (!returnType->isVoidType()) {
// Determine the function body end location. A function without a body
- // uses its declaration's location, and a null fd
- // uses loc.
+ // uses its declaration's location, and a null fd uses loc.
SourceLocation bodyEndLoc = loc;
if (fd) {
if (Stmt *body = fd->getBody())
@@ -580,8 +579,8 @@ void CIRGenFunction::startFunction(GlobalDecl gd, QualType returnType,
prologueCleanupDepth = ehStack.stable_begin();
// Determine the function body begin location for the prolog. A function
- // without a body uses its declaration's location, as classic codegen does,
- // and a null fd uses startLoc.
+ // without a body uses its declaration's location, and a null fd uses
+ // startLoc.
SourceLocation bodyBeginLoc = startLoc;
if (fd) {
if (Stmt *body = fd->getBody())
diff --git a/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp b/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp
index da3d7cc3aea53e..741ee78c7fdad1 100644
--- a/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/HoistAllocas.cpp
@@ -96,7 +96,7 @@ static void process(mlir::ModuleOp mod, cir::FuncOp func) {
// Hoisted allocas go after the allocas already at the start of the
// destination block, so the return value and parameter allocas stay
- // first, as in classic codegen.
+ // first.
mlir::Operation *&insertPoint = insertPoints[destBlock];
if (!insertPoint)
insertPoint = &*llvm::find_if(*destBlock, [](mlir::Operation &blockOp) {
More information about the cfe-commits
mailing list