[llvm-branch-commits] [clang] [CIR] Make cir-canonicalize a full canonicalizer (PR #240769)
Henrich Lauko via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Nov 10 01:51:34 PST 2026
https://github.com/xlauko created https://github.com/llvm/llvm-project/pull/240769
`cir-canonicalize` applied the CIR canonicalization patterns and folders only to a hand-written list of operations. It now builds the pattern set once in `initialize()` and runs the greedy driver over every operation, with dead code elimination disabled through the new `GreedyRewriteConfig` option from llvm/llvm-project#240768, so unused locals and ignored expressions stay as in classic codegen; only the inputs of a folded operation can be left unused, which is where most of the test updates come from. Empty `cir.scope` and `cir.switch` were removed only because they were dead, so they get explicit canonicalization patterns. The pass uses the multi-op driver because the region driver always erases blocks without a CFG predecessor, and a block that starts with `cir.label` is reached only through `cir.goto` until the goto solver runs; region simplification stays off for the same reason. A `test-convergence` option fails the pass when the driver does not reach a fixpoint, and `clang/test/CIR` passes with it forced on and with expensive pattern API checks enabled.
Assisted-by: Claude Code (claude-opus-5-5).
>From 1a8375b9f867db7b3389fe38ac21f2acb4a2338e Mon Sep 17 00:00:00 2001
From: Henrich Lauko <hlauko at nvidia.com>
Date: Tue, 10 Nov 2026 09:48:02 +0000
Subject: [PATCH] [CIR] Make cir-canonicalize a full canonicalizer
cir-canonicalize applied the CIR canonicalization patterns and folders
only to a hand-written list of operations. It now builds the pattern set
once in initialize() and runs the greedy driver over every operation, so
every pattern and folder applies everywhere. Dead code elimination is
disabled: CIR stays close to the source, so unused locals and ignored
expressions are kept as in classic codegen, and only the inputs of a
folded operation can be left unused. Empty scopes and switches were
removed only because they were dead, so they get explicit
canonicalization patterns.
The pass uses the multi-op driver because the region driver always
erases blocks without a CFG predecessor, and a block that starts with
cir.label is reached only through cir.goto until the goto solver runs.
Region simplification stays off for the same reason. The new
test-convergence option fails the pass when the driver does not reach a
fixpoint, as in the upstream canonicalizer.
Assisted-by: Claude Code (claude-opus-5-5).
---
clang/include/clang/CIR/Dialect/IR/CIROps.td | 2 +
clang/include/clang/CIR/Dialect/Passes.td | 9 +-
clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 20 ++++
.../Dialect/Transforms/CIRCanonicalize.cpp | 103 ++++++++----------
clang/test/CIR/CodeGen/atomic-libcall.c | 4 +
clang/test/CIR/CodeGen/atomic.c | 3 +
clang/test/CIR/CodeGen/bitint-record-layout.c | 3 +
clang/test/CIR/CodeGen/fixed-point-arith.cpp | 11 ++
clang/test/CIR/CodeGen/fold-during-cg.c | 16 +--
.../CIR/CodeGen/implicit-value-init-expr.cpp | 1 +
clang/test/CIR/CodeGen/new.cpp | 4 +
.../no-unique-address-empty-consteval.cpp | 3 +
.../test/CIR/CodeGen/paren-list-agg-init.cpp | 2 +-
.../CIR/CodeGen/pointer-to-data-member.cpp | 6 +-
clang/test/CIR/CodeGen/union.c | 5 +
clang/test/CIR/CodeGen/vla.c | 10 +-
clang/test/CIR/CodeGen/void-value-expr.cpp | 2 +
clang/test/CIR/CodeGenCXX/new-array-init.cpp | 6 +
clang/test/CIR/CodeGenOpenACC/combined-copy.c | 1 +
.../compute-reduction-clause-default-ops.c | 48 ++++++++
.../compute-reduction-clause-float.c | 6 +
.../compute-reduction-clause-int.c | 6 +
.../compute-reduction-clause-unsigned-int.c | 6 +
clang/test/CIR/CodeGenOpenACC/data.c | 1 +
clang/test/CIR/CodeGenOpenACC/enter-data.c | 3 +
clang/test/CIR/CodeGenOpenACC/exit-data.c | 3 +
clang/test/CIR/CodeGenOpenACC/kernels.c | 3 +
clang/test/CIR/CodeGenOpenACC/parallel.c | 3 +
clang/test/CIR/CodeGenOpenACC/serial.c | 3 +
clang/test/CIR/CodeGenOpenACC/update.c | 2 +
.../CIR/CodeGenSYCL/global-address-space.cpp | 1 +
clang/test/CIR/Transforms/bit.cir | 25 +++++
.../CIR/Transforms/builtin-int-cast-fold.cir | 1 +
.../CIR/Transforms/canonicalize-dead-code.cir | 42 +++++++
clang/test/CIR/Transforms/canonicalize.cir | 31 +++++-
clang/test/CIR/Transforms/select.cir | 3 +
clang/test/CIR/Transforms/vector-cmp-fold.cir | 30 +++++
.../CIR/Transforms/vector-create-fold.cir | 4 +
.../vector-shuffle-dynamic-fold.cir | 4 +
.../CIR/Transforms/vector-shuffle-fold.cir | 6 +
.../CIR/Transforms/vector-ternary-fold.cir | 3 +
41 files changed, 374 insertions(+), 71 deletions(-)
create mode 100644 clang/test/CIR/Transforms/canonicalize-dead-code.cir
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 93c91a48bd0c7b..066debaa8c8e14 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -1417,6 +1417,7 @@ def CIR_ScopeOp : CIR_EnterAnyRegionBranchOpBase<"scope", [
let regions = (region AnyRegion:$scopeRegion);
let hasFolder = 1;
+ let hasCanonicalizeMethod = 1;
let hasVerifier = 1;
let skipDefaultBuilders = 1;
let assemblyFormat = [{
@@ -1797,6 +1798,7 @@ def CIR_SwitchOp : CIR_EnterAnyRegionBranchOpBase<"switch", [
let regions = (region AnyRegion:$body);
+ let hasCanonicalizeMethod = 1;
let skipDefaultBuilders = 1;
let builders = [
OpBuilder<(ins "mlir::Value":$condition,
diff --git a/clang/include/clang/CIR/Dialect/Passes.td b/clang/include/clang/CIR/Dialect/Passes.td
index 787a9d8f29b899..de2387ae10e62f 100644
--- a/clang/include/clang/CIR/Dialect/Passes.td
+++ b/clang/include/clang/CIR/Dialect/Passes.td
@@ -14,7 +14,9 @@ include "mlir/Pass/PassBase.td"
def CIRCanonicalize : Pass<"cir-canonicalize"> {
let summary = "Performs CIR canonicalization";
let description = [{
- Perform canonicalizations on CIR and removes some redundant operations.
+ Applies the canonicalization patterns and folders of every CIR operation
+ to all operations until a fixpoint is reached. Operations that are dead
+ but not folded away are kept.
This pass performs basic cleanup and canonicalization transformations that
are not intended to affect CIR-to-source fidelity and high-level code
@@ -25,6 +27,11 @@ def CIRCanonicalize : Pass<"cir-canonicalize"> {
`cir-simplify` pass.
}];
+ let options = [
+ Option<"testConvergence", "test-convergence", "bool", /*default=*/"false",
+ "Test only: Fail pass on non-convergence to detect cyclic pattern">
+ ];
+
let constructor = "mlir::createCIRCanonicalizePass()";
let dependentDialects = ["cir::CIRDialect"];
}
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index 35f390afffe8ba..b54dd8c7fa7224 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -2063,6 +2063,15 @@ LogicalResult cir::ScopeOp::fold(FoldAdaptor /*adaptor*/,
return success();
}
+/// Erases a scope that yields no value and contains only its terminator.
+LogicalResult cir::ScopeOp::canonicalize(ScopeOp op,
+ PatternRewriter &rewriter) {
+ if (op.getNumResults() != 0 || !op.isEmpty())
+ return failure();
+ rewriter.eraseOp(op);
+ return success();
+}
+
//===----------------------------------------------------------------------===//
// CleanupScopeOp
//===----------------------------------------------------------------------===//
@@ -2345,6 +2354,17 @@ void cir::CaseOp::build(OpBuilder &builder, OperationState &result,
// SwitchOp
//===----------------------------------------------------------------------===//
+/// Erases a switch whose body contains only its terminator.
+LogicalResult cir::SwitchOp::canonicalize(SwitchOp op,
+ PatternRewriter &rewriter) {
+ Region &body = op.getBody();
+ if (!body.hasOneBlock() || !llvm::hasSingleElement(body.front()) ||
+ !isa<cir::YieldOp>(body.front().front()))
+ return failure();
+ rewriter.eraseOp(op);
+ return success();
+}
+
void cir::SwitchOp::build(OpBuilder &builder, OperationState &result,
Value cond, BuilderOpStateCallbackRef switchBuilder) {
assert(switchBuilder && "the builder callback for regions must be present");
diff --git a/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp b/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp
index 31fbdcecc44141..f2a821db949904 100644
--- a/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp
@@ -6,25 +6,21 @@
//
//===----------------------------------------------------------------------===//
//
-// This file implements pass that canonicalizes CIR operations, eliminating
-// redundant branches, empty scopes, and other unnecessary operations.
+// This file implements the CIR canonicalization pass. It applies the
+// canonicalization patterns and folders of the CIR dialect to every operation
+// until a fixpoint is reached, like the upstream MLIR canonicalizer restricted
+// to CIR patterns.
//
//===----------------------------------------------------------------------===//
#include "PassDetail.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/IR/Block.h"
-#include "mlir/IR/Operation.h"
#include "mlir/IR/PatternMatch.h"
-#include "mlir/IR/Region.h"
-#include "mlir/Support/LogicalResult.h"
+#include "mlir/Rewrite/FrozenRewritePatternSet.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
#include "clang/CIR/Dialect/IR/CIRDialect.h"
#include "clang/CIR/Dialect/Passes.h"
-#include "clang/CIR/MissingFeatures.h"
using namespace mlir;
-using namespace cir;
namespace mlir {
#define GEN_PASS_DEF_CIRCANONICALIZE
@@ -33,60 +29,55 @@ namespace mlir {
namespace {
-//===----------------------------------------------------------------------===//
-// CIRCanonicalizePass
-//===----------------------------------------------------------------------===//
-
struct CIRCanonicalizePass
: public impl::CIRCanonicalizeBase<CIRCanonicalizePass> {
using CIRCanonicalizeBase::CIRCanonicalizeBase;
- // The same operation rewriting done here could have been performed
- // by CanonicalizerPass (adding hasCanonicalizer for target Ops and
- // implementing the same from above in CIRDialects.cpp). However, it's
- // currently too aggressive for static analysis purposes, since it might
- // remove things where a diagnostic can be generated.
- //
- // FIXME: perhaps we can add one more mode to GreedyRewriteConfig to
- // disable this behavior.
- void runOnOperation() override;
-};
-
-void CIRCanonicalizePass::runOnOperation() {
- RewritePatternSet patterns(&getContext());
-
- // Collect canonicalization patterns from CIR ops.
- mlir::Dialect *cir = getContext().getLoadedDialect<cir::CIRDialect>();
- for (mlir::RegisteredOperationName op :
- getContext().getRegisteredOperations())
- if (&op.getDialect() == cir)
- op.getCanonicalizationPatterns(patterns, &getContext());
+ LogicalResult initialize(MLIRContext *context) override {
+ RewritePatternSet owningPatterns(context);
+ Dialect *cir = context->getLoadedDialect<cir::CIRDialect>();
+ cir->getCanonicalizationPatterns(owningPatterns);
+ for (RegisteredOperationName op : context->getRegisteredOperations())
+ if (&op.getDialect() == cir)
+ op.getCanonicalizationPatterns(owningPatterns, context);
+ patterns =
+ std::make_shared<FrozenRewritePatternSet>(std::move(owningPatterns));
+ return success();
+ }
- // Collect operations to apply patterns.
- llvm::SmallVector<Operation *, 16> ops;
- getOperation()->walk([&](Operation *op) {
- assert(!cir::MissingFeatures::tryOp());
- assert(!cir::MissingFeatures::callOp());
+ void runOnOperation() override {
+ // Seed the worklist with every nested operation in pre-order. The driver
+ // pops from the back, so reverse the list to visit the IR top-down.
+ SmallVector<Operation *> ops;
+ getOperation()->walk<WalkOrder::PreOrder>([&](Operation *op) {
+ if (op != getOperation())
+ ops.push_back(op);
+ });
+ std::reverse(ops.begin(), ops.end());
- // Many operations are here to perform a manual `fold` in
- // applyOpPatternsGreedily.
- if (isa<BrOp, BrCondOp, BuiltinIntCastOp, CastOp, ScopeOp, SwitchOp,
- SelectOp, IncOp, DecOp, MinusOp, FNegOp, NotOp, AddOp, MulOp, AndOp,
- OrOp, XorOp, MaxOp, MinOp, ComplexCreateOp, ComplexImagOp,
- ComplexRealOp, VecCmpOp, VecCreateOp, VecExtractOp, VecShuffleOp,
- VecShuffleDynamicOp, VecTernaryOp, BitClrsbOp, BitClzOp, BitCtzOp,
- BitFfsOp, BitParityOp, BitPopcountOp, BitReverseOp, ByteSwapOp,
- RotateOp, ConstantOp, CleanupScopeOp>(op))
- ops.push_back(op);
- });
+ // Use the multi-op driver rather than applyPatternsGreedily on the
+ // regions: the region driver always erases blocks that have no CFG
+ // predecessor, but before the goto solver runs, a block that starts with
+ // a `cir.label` is reached only through `cir.goto`, which is not a CFG
+ // edge. For the same reason region simplification is not run.
+ //
+ // Dead operations are kept: CIR stays close to the source, so an unused
+ // local or an ignored expression is still emitted, as in classic codegen.
+ GreedyRewriteConfig config;
+ config.setScope(&getOperation()->getRegion(0));
+ config.enableDeadCodeElimination(false);
+ bool changed = false;
+ LogicalResult converged =
+ applyOpPatternsGreedily(ops, *patterns, config, &changed);
+ // Canonicalization is best-effort. Non-convergence is not a pass failure.
+ if (testConvergence && failed(converged))
+ signalPassFailure();
+ if (!changed)
+ markAllAnalysesPreserved();
+ }
- // Apply patterns. Scope the rewrite to the body region, which encloses
- // the common ancestor the driver would otherwise search for.
- GreedyRewriteConfig config;
- config.setScope(&getOperation()->getRegion(0));
- if (applyOpPatternsGreedily(ops, std::move(patterns), config).failed())
- signalPassFailure();
-}
+ std::shared_ptr<const FrozenRewritePatternSet> patterns;
+};
} // namespace
diff --git a/clang/test/CIR/CodeGen/atomic-libcall.c b/clang/test/CIR/CodeGen/atomic-libcall.c
index b20eefce22b76b..cd2fdbe2fdb2e5 100644
--- a/clang/test/CIR/CodeGen/atomic-libcall.c
+++ b/clang/test/CIR/CodeGen/atomic-libcall.c
@@ -38,6 +38,7 @@ void scoped_load(struct Big *ptr) {
__scoped_atomic_load(ptr, &b, __ATOMIC_RELAXED, __MEMORY_SCOPE_SYSTEM);
// CIR: %[[DEST_SLOT:.+]] = cir.alloca "b" align(4) : !cir.ptr<!rec_Big>
// CIR: %[[PTR:.+]] = cir.load align(8) %{{.+}} : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[PTR_INTPTR:.+]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!rec_Big> -> !cir.ptr<!cir.int<u, 192>>
// CIR-NEXT: %[[DEST_INTPTR:.+]] = cir.cast bitcast %[[DEST_SLOT]] : !cir.ptr<!rec_Big> -> !cir.ptr<!cir.int<u, 192>>
// CIR-NEXT: %[[SIZE:.+]] = cir.const #cir.int<24> : !u64i
@@ -102,6 +103,7 @@ void scoped_store(struct Big *dest, struct Big *val) {
__scoped_atomic_store(dest, val, __ATOMIC_RELAXED, __MEMORY_SCOPE_SYSTEM);
// CIR: %[[DEST_PTR:.+]] = cir.load align(8) %{{.+}} : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[VALUE_PTR:.+]] = cir.load align(8) %{{.+}} : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
// CIR-NEXT: %[[DEST_INTPTR:.+]] = cir.cast bitcast %[[DEST_PTR]] : !cir.ptr<!rec_Big> -> !cir.ptr<!cir.int<u, 192>>
// CIR-NEXT: %[[VALUE_INTPTR:.+]] = cir.cast bitcast %[[VALUE_PTR]] : !cir.ptr<!rec_Big> -> !cir.ptr<!cir.int<u, 192>>
@@ -177,6 +179,7 @@ void scoped_exchange(struct Big *ptr, struct Big *val, struct Big *old) {
// CIR-NEXT: %[[VAL:.*]] = cir.alloca "val" align(8) init : !cir.ptr<!cir.ptr<!rec_Big>>
// CIR-NEXT: %[[OLD:.*]] = cir.alloca "old" align(8) init : !cir.ptr<!cir.ptr<!rec_Big>>
// CIR: %[[LOAD_PTR:.*]] = cir.load align(8) %[[PTR]] : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[LOAD_VAL:.*]] = cir.load align(8) %[[VAL]] : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
// CIR-NEXT: %[[LOAD_OLD:.*]] = cir.load align(8) %[[OLD]] : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
// CIR-NEXT: %[[CAST_PTR:.*]] = cir.cast bitcast %[[LOAD_PTR]] : !cir.ptr<!rec_Big> -> !cir.ptr<!cir.int<u, 192>>
@@ -284,6 +287,7 @@ void scoped_cmpxchg(struct Big *ptr, struct Big *expected, struct Big *desired)
__scoped_atomic_compare_exchange(ptr, expected, desired, /*weak=*/0, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE, __MEMORY_SCOPE_SYSTEM);
// CIR: %[[PTR:.+]] = cir.load align(8) %{{.+}} : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[EXPECTED:.+]] = cir.load align(8) %{{.+}} : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
// CIR-NEXT: %[[DESIRED:.+]] = cir.load align(8) %{{.+}} : !cir.ptr<!cir.ptr<!rec_Big>>, !cir.ptr<!rec_Big>
// CIR-NEXT: %[[PTR_INTPTR:.+]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!rec_Big> -> !cir.ptr<!cir.int<u, 192>>
diff --git a/clang/test/CIR/CodeGen/atomic.c b/clang/test/CIR/CodeGen/atomic.c
index 97e7435d68f7af..f151dd43e036ea 100644
--- a/clang/test/CIR/CodeGen/atomic.c
+++ b/clang/test/CIR/CodeGen/atomic.c
@@ -102,12 +102,15 @@ void init_with_padding(_Atomic struct S1 *p) {
// CIR-NEXT: cir.libc.memset %[[MEMSET_SIZE]] bytes at %[[PTR_VOID]] align(8) to %[[MEMSET_VALUE]] : !cir.ptr<!void>, !u8i, !u64i
// CIR-NEXT: %[[VALUE_PTR:.+]] = cir.get_member %[[PTR]][0] {name = "value"} : !cir.ptr<!rec_anon_struct> -> !cir.ptr<!rec_S1>
// CIR-NEXT: %[[X_PTR:.+]] = cir.get_member %[[VALUE_PTR]][0] {name = "x"} : !cir.ptr<!rec_S1> -> !cir.ptr<!s16i>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[X_INIT:.+]] = cir.const #cir.int<1> : !s16i
// CIR-NEXT: cir.store align(8) %[[X_INIT]], %[[X_PTR]] : !s16i, !cir.ptr<!s16i>
// CIR-NEXT: %[[Y_PTR:.+]] = cir.get_member %[[VALUE_PTR]][1] {name = "y"} : !cir.ptr<!rec_S1> -> !cir.ptr<!s16i>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[Y_INIT:.+]] = cir.const #cir.int<2> : !s16i
// CIR-NEXT: cir.store align(2) %[[Y_INIT]], %[[Y_PTR]] : !s16i, !cir.ptr<!s16i>
// CIR-NEXT: %[[Z_PTR:.+]] = cir.get_member %[[VALUE_PTR]][2] {name = "z"} : !cir.ptr<!rec_S1> -> !cir.ptr<!s16i>
+ // CIR-NEXT: %{{.+}} = cir.const #cir.int<3> : !s32i
// CIR-NEXT: %[[Z_INIT:.+]] = cir.const #cir.int<3> : !s16i
// CIR-NEXT: cir.store align(4) %[[Z_INIT]], %[[Z_PTR]] : !s16i, !cir.ptr<!s16i>
diff --git a/clang/test/CIR/CodeGen/bitint-record-layout.c b/clang/test/CIR/CodeGen/bitint-record-layout.c
index a16a79a4090107..1424bfb43b41e7 100644
--- a/clang/test/CIR/CodeGen/bitint-record-layout.c
+++ b/clang/test/CIR/CodeGen/bitint-record-layout.c
@@ -201,6 +201,7 @@ _BitInt(128) get_bi(void) { return l128[1].bi; }
// CIR-LABEL: cir.func no_inline dso_local @get_bi() -> !s128i_bitint
// CIR-NEXT: %[[RET_ALLOC:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!s128i_bitint>
// CIR-NEXT: %[[GET_GLOB:.*]] = cir.get_global @l128 : !cir.ptr<!cir.array<!rec_Last128 x 2>>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
// CIR-NEXT: %[[ARR_GEP:.*]] = cir.get_element %[[GET_GLOB]][%[[ONE]] : !s64i] : !cir.ptr<!cir.array<!rec_Last128 x 2>> -> !cir.ptr<!rec_Last128>
// CIR-NEXT: %[[GET_BI:.*]] = cir.get_member %[[ARR_GEP]][2] {name = "bi"} : !cir.ptr<!rec_Last128> -> !cir.ptr<!s128i_bitint>
@@ -215,9 +216,11 @@ _BitInt(128) get_bi2(void) { return arrMem[1].bi[1]; }
// CIR-LABEL: cir.func no_inline dso_local @get_bi2() -> !s128i_bitint attributes {"cir.target-features" = "+cx8,+mmx,+sse,+sse2,+x87", nothrow, optnone} {
// CIR-NEXT: %[[RET_ALLOC:.*]] = cir.alloca "__retval" align(8) : !cir.ptr<!s128i_bitint>
// CIR-NEXT: %[[GET_GLOB:.*]] = cir.get_global @arrMem : !cir.ptr<!cir.array<!rec_ArrMem x 2>>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[ONE_2:.*]] = cir.const #cir.int<1> : !s64i
// CIR-NEXT: %[[ARR_GEP:.*]] = cir.get_element %[[GET_GLOB]][%[[ONE_2]] : !s64i] : !cir.ptr<!cir.array<!rec_ArrMem x 2>> -> !cir.ptr<!rec_ArrMem>
// CIR-NEXT: %[[GET_BI_ARR:.*]] = cir.get_member %[[ARR_GEP]][2] {name = "bi"} : !cir.ptr<!rec_ArrMem> -> !cir.ptr<!cir.array<!s128i_bitint x 2>>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
// CIR-NEXT: %[[GET_BI_ELT:.*]] = cir.get_element %[[GET_BI_ARR]][%[[ONE]] : !s64i] : !cir.ptr<!cir.array<!s128i_bitint x 2>> -> !cir.ptr<!s128i_bitint>
// CIR-NEXT: %[[LOAD_BI:.*]] = cir.load align(8) %[[GET_BI_ELT]] : !cir.ptr<!s128i_bitint>, !s128i_bitint
diff --git a/clang/test/CIR/CodeGen/fixed-point-arith.cpp b/clang/test/CIR/CodeGen/fixed-point-arith.cpp
index 1e1f11860dd806..b204c92f950274 100644
--- a/clang/test/CIR/CodeGen/fixed-point-arith.cpp
+++ b/clang/test/CIR/CodeGen/fixed-point-arith.cpp
@@ -452,6 +452,7 @@ _Fract shr3(_Fract f, unsigned u) {
// 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: %{{.+}} = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
@@ -473,6 +474,7 @@ _Accum inc(_Accum a) {
// 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: %{{.+}} = cir.const #cir.int<1> : !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s16i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s16i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1:.*]] : !s16i, %[[SHIFT_NUM]] : !s16i) -> !s16i
@@ -494,6 +496,7 @@ _Fract inc2(_Fract f) {
// 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: %{{.+}} = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
@@ -515,6 +518,7 @@ _Accum dec(_Accum a) {
// 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: %{{.+}} = cir.const #cir.int<1> : !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s16i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s16i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !s16i, %[[SHIFT_NUM]] : !s16i) -> !s16i
@@ -622,6 +626,8 @@ _Sat _Accum satDiv(_Sat _Accum a, _Sat _Accum b) {
// 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: %{{.+}} = cir.const #cir.int<2> : !s32i
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<2> : !u32i
// 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
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
@@ -707,6 +713,8 @@ _Sat _Fract satShr2(_Sat _Fract f, int i) {
// 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: %{{.+}} = cir.const #cir.int<1> : !s32i
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<-1> : !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>
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !cir.int<s, 47>, %[[SHIFT_NUM]] : !cir.int<s, 47>) -> !cir.int<s, 47>
@@ -736,6 +744,8 @@ _Sat _Accum satInc(_Sat _Accum a) {
// 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: %{{.+}} = cir.const #cir.int<1> : !s16i
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<-1> : !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>
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !cir.int<s, 31>, %[[SHIFT_NUM]] : !cir.int<s, 31>) -> !cir.int<s, 31>
@@ -766,6 +776,7 @@ _Sat _Fract satDec(_Sat _Fract f) {
// 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: %{{.+}} = cir.const #cir.int<1> : !u16i
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<16> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[ONE]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
diff --git a/clang/test/CIR/CodeGen/fold-during-cg.c b/clang/test/CIR/CodeGen/fold-during-cg.c
index 137d5bb3d4f20d..1e2eb0bbcd2419 100644
--- a/clang/test/CIR/CodeGen/fold-during-cg.c
+++ b/clang/test/CIR/CodeGen/fold-during-cg.c
@@ -1,9 +1,9 @@
// RUN: %clang_cc1 -std=c23 -triple x86_64-unknown-linux-gnu -mmlir -mlir-print-ir-before=cir-canonicalize -Wno-unused-value -Wno-constant-conversion -Wno-literal-conversion -fclangir -emit-cir %s -o %t.cir 2> %t-before.cir
// Note: The "before" check intentionally uses the same CIR check prefixes to
// verify that the IR is folded during code generation and not during
-// canonicalization. In a few cases, it is necessary to match an unused
-// duplicate constant that will be erased during canonicalization.
-// RUN: FileCheck --input-file=%t-before.cir %s -check-prefixes=CIR,CIR-DUP,ALL
+// canonicalization. In a few cases, an unused duplicate constant is
+// matched explicitly; canonicalization does not erase it.
+// RUN: FileCheck --input-file=%t-before.cir %s -check-prefixes=CIR,ALL
// RUN: FileCheck --input-file=%t.cir %s -check-prefixes=CIR,ALL
// RUN: %clang_cc1 -std=c23 -triple x86_64-unknown-linux-gnu -Wno-unused-value -Wno-constant-conversion -Wno-literal-conversion -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefixes=LLVM_OGCG,ALL
@@ -133,7 +133,7 @@ void fold_int_minus() {
// LLVM_OGCG: store i32 -2, ptr %{{.*}}
n = -(-3);
- // CIR-DUP: %[[UNUSED_THREE:.*]] = cir.const #cir.int<3> : !s32i
+ // CIR: %[[UNUSED_THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR-NOT: cir.minus
// CIR: cir.store{{.*}} %[[THREE]], %{{.*}}
@@ -158,7 +158,7 @@ void fold_int_minus() {
// LLVM_OGCG: store i16 -2, ptr %{{.*}}
s = -(-3);
- // CIR-DUP: %[[UNUSED_THREE:.*]] = cir.const #cir.int<3> : !s32i
+ // CIR: %[[UNUSED_THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !s16i
// CIR-NOT: cir.minus
// CIR: cir.store{{.*}} %[[THREE]], %{{.*}}
@@ -183,7 +183,7 @@ void fold_int_minus() {
// LLVM_OGCG: store i32 -2, ptr %{{.*}}
u = -(-3);
- // CIR-DUP: %[[UNUSED_THREE:.*]] = cir.const #cir.int<3> : !s32i
+ // CIR: %[[UNUSED_THREE:.*]] = cir.const #cir.int<3> : !s32i
// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !u32i
// CIR-NOT: cir.minus
// CIR: cir.store{{.*}} %[[THREE]], %{{.*}}
@@ -238,7 +238,7 @@ void fold_float_minus() {
// LLVM_OGCG: store float -2.000000e+00, ptr %{{.*}}
f = -(-3.0f);
- // CIR-DUP: %[[UNUSED_THREE:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.float
+ // CIR: %[[UNUSED_THREE:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.float
// CIR: %[[THREE:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.float
// CIR-NOT: cir.minus
// CIR: cir.store{{.*}} %[[THREE]], %{{.*}}
@@ -251,7 +251,7 @@ void fold_float_minus() {
// LLVM_OGCG: store double -2.000000e+00, ptr %{{.*}}
d = -(-3.0);
- // CIR-DUP: %[[UNUSED_THREE:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.double
+ // CIR: %[[UNUSED_THREE:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.double
// CIR: %[[THREE:.*]] = cir.const #cir.fp<3.000000e+00> : !cir.double
// CIR-NOT: cir.minus
// CIR: cir.store{{.*}} %[[THREE]], %{{.*}}
diff --git a/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp b/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
index 399e72bcf202d4..e780b9780eb813 100644
--- a/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
+++ b/clang/test/CIR/CodeGen/implicit-value-init-expr.cpp
@@ -14,6 +14,7 @@ void test(void *p) {
// CIR: cir.func{{.*}} @_Z4testPv
// CIR-NEXT: %[[P:.*]] = cir.alloca "p" align(8) init : !cir.ptr<!cir.ptr<!void>>
// CIR-NEXT: cir.store %arg0, %[[P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<4> : !u64i
// CIR-NEXT: %[[P1:.*]] = cir.load align(8) %[[P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR-NEXT: %[[P2:.*]] = cir.cast bitcast %[[P1]] : !cir.ptr<!void> -> !cir.ptr<!s32i>
// CIR-NEXT: %[[P3:.*]] = cir.const #cir.int<0> : !s32i
diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp
index 3a26f7264c0001..e89a030ab360ea 100644
--- a/clang/test/CIR/CodeGen/new.cpp
+++ b/clang/test/CIR/CodeGen/new.cpp
@@ -464,6 +464,7 @@ void t_new_huge_float_size() {
}
// CHECK: cir.func {{.*}} @_Z21t_new_huge_float_sizev()
+// CHECK: %{{.+}} = cir.const #cir.int<18446744073709551615> : !u64i
// CHECK: %[[ALLOCATION_SIZE:.*]] = cir.const #cir.int<18446744073709551615> : !u64i
// CHECK: %{{.*}} = cir.call @_Znam(%[[ALLOCATION_SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
@@ -1140,6 +1141,7 @@ void test_array_new_with_ctor_partial_init_list() {
// CIR-BEFORE-LPP: cir.func {{.*}} @_Z42test_array_new_with_ctor_partial_init_listv
// CIR-BEFORE-LPP: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!rec_G>>
+// CIR-BEFORE-LPP: %{{.+}} = cir.const #cir.int<8> : !u64i
// CIR-BEFORE-LPP: %[[EIGHT:.*]] = cir.const #cir.int<8> : !u64i
// CIR-BEFORE-LPP: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[EIGHT]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef})
// CIR-BEFORE-LPP: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_G>
@@ -1161,6 +1163,7 @@ void test_array_new_with_ctor_partial_init_list() {
// CHECK: cir.func {{.*}} @_Z42test_array_new_with_ctor_partial_init_listv
// CHECK: %[[P_ADDR:.*]] = cir.alloca "p" {{.*}} init : !cir.ptr<!cir.ptr<!rec_G>>
+// CHECK: %{{.+}} = cir.const #cir.int<8> : !u64i
// CHECK: %[[EIGHT:.*]] = cir.const #cir.int<8> : !u64i
// CHECK: %[[RAW_PTR:.*]] = cir.call @_Znam(%[[EIGHT]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef})
// CHECK: %[[BEGIN:.*]] = cir.cast bitcast %[[RAW_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_G>
@@ -1240,6 +1243,7 @@ namespace gh227980 {
}
// CHECK-LABEL: cir.func{{.*}}@_ZN8gh22798015huge_float_sizeEv()
+// CHECK: %{{.+}} = cir.const #cir.int<18446744073709551615> : !u64i
// CHECK: %[[NEG:.*]] = cir.const #cir.int<18446744073709551615> : !u64i
// CHECK: cir.call @_Znam(%[[NEG]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef})
diff --git a/clang/test/CIR/CodeGen/no-unique-address-empty-consteval.cpp b/clang/test/CIR/CodeGen/no-unique-address-empty-consteval.cpp
index 403a191a40f751..026f69f8d19b57 100644
--- a/clang/test/CIR/CodeGen/no-unique-address-empty-consteval.cpp
+++ b/clang/test/CIR/CodeGen/no-unique-address-empty-consteval.cpp
@@ -65,6 +65,7 @@ struct U {
// CIR-LABEL: cir.func {{.*}} @_Z19test_aggregate_initv(
// CIR: %[[V3:.*]] = cir.get_member %{{.+}}[0] {name = "v3"}
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<39612> : !s32i
// CIR-NEXT: %[[C:.*]] = cir.const #cir.int<39612>
// CIR-NEXT: cir.store align(8) %[[C]], %[[V3]] : !u64i, !cir.ptr<!u64i>
// CIR-NOT: #cir.zero : !rec_Empty
@@ -94,6 +95,7 @@ unsigned long test_default_member_init() {
// CIR: %[[V:.*]] = cir.get_member %{{.+}}[0] {name = "v"}
// CIR: %[[X:.*]] = cir.load align(8) %{{.+}} : !cir.ptr<!u64i>, !u64i
// CIR-NEXT: cir.store align(8) %[[X]], %[[V]] : !u64i, !cir.ptr<!u64i>
+// CIR-NEXT: %{{.+}} = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_S> -> !cir.ptr<!rec_Empty>
// CIR-NEXT: cir.return
// LLVM-LABEL: define {{.*}} void @_ZN1SC2Em(
@@ -119,6 +121,7 @@ unsigned long test_default_member_init() {
// CIR: %[[V4:.*]] = cir.get_member %{{.+}}[0] {name = "v4"}
// CIR: %[[X4:.*]] = cir.load align(8) %{{.+}} : !cir.ptr<!u64i>, !u64i
// CIR-NEXT: cir.store align(8) %[[X4]], %[[V4]] : !u64i, !cir.ptr<!u64i>
+// CIR-NEXT: %{{.+}} = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_V> -> !cir.ptr<!rec_Empty>
// CIR-NEXT: cir.return
// LLVM-LABEL: define {{.*}} void @_ZN1VC2Em(
diff --git a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
index e240aecaabf516..beda22e79786a4 100644
--- a/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
+++ b/clang/test/CIR/CodeGen/paren-list-agg-init.cpp
@@ -363,7 +363,7 @@ D foo8() {
// CIR: %[[FP_2:.*]] = cir.const #cir.fp<2
// CIR: cir.store align(8) %[[FP_2]], %[[GET_J]] : !cir.double, !cir.ptr<!cir.double>
// CIR: %[[GET_C:.*]] = cir.get_member %[[D_ALLOCA]][3] {name = "c"} : !cir.ptr<![[STRUCT_D]]> -> !cir.ptr<![[STRUCT_A]]>
-// CIR: %[[GET_C_PTR_I8:.*]] = cir.cast bitcast %12 : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!u8i>
+// CIR: %[[GET_C_PTR_I8:.*]] = cir.cast bitcast %[[GET_C]] : !cir.ptr<![[STRUCT_A]]> -> !cir.ptr<!u8i>
// CIR: %[[CONST_0:.*]] = cir.const #cir.int<0> : !u8i
// CIR: %[[CONST_16:.*]] = cir.const #cir.int<16> : !u64i
// CIR: %[[GET_C_VOID_PTR:.*]] = cir.cast bitcast %[[GET_C_PTR_I8]] : !cir.ptr<!u8i> -> !cir.ptr<!void>
diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
index c0dd470e4a66e5..27b60cc8ec2a03 100644
--- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
+++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp
@@ -458,7 +458,8 @@ void useHasField() {
// CIR-BEFORE-LABEL: cir.func {{.*}}_Z14changeFieldPtrIXadL_ZN8hasField5fieldEEEEvRS0_
// CIR-BEFORE: %[[ARG:.*]] = cir.alloca "hf" {{.*}} : !cir.ptr<!cir.ptr<!rec_hasField>>
-// CIR-BEFORE: %[[ONE:.*]] = cir.const #cir.int<1>
+// CIR-BEFORE: %{{.+}} = cir.const #cir.int<1> : !s32i
+// CIR-BEFORE: %[[ONE:.*]] = cir.const #cir.int<1> : !u32i
// CIR-BEFORE: %[[LOAD_ARG:.*]] = cir.load %[[ARG]] : !cir.ptr<!cir.ptr<!rec_hasField>>, !cir.ptr<!rec_hasField>
// CIR-BEFORE: %[[GET_DM:.*]] = cir.const #cir.data_member<[0]> : !cir.data_member<!u32i in !rec_hasField>
// CIR-BEFORE: %[[GET_MEM:.*]] = cir.get_runtime_member %[[LOAD_ARG]][%[[GET_DM]] : !cir.data_member<!u32i in !rec_hasField>] : !cir.ptr<!rec_hasField> -> !cir.ptr<!u32i>
@@ -466,7 +467,8 @@ void useHasField() {
// CIR-AFTER-LABEL: cir.func {{.*}}_Z14changeFieldPtrIXadL_ZN8hasField5fieldEEEEvRS0_
// CIR-AFTER: %[[ARG:.*]] = cir.alloca "hf" {{.*}} : !cir.ptr<!cir.ptr<!rec_hasField>>
-// CIR-AFTER: %[[ONE:.*]] = cir.const #cir.int<1>
+// CIR-AFTER: %{{.+}} = cir.const #cir.int<1> : !s32i
+// CIR-AFTER: %[[ONE:.*]] = cir.const #cir.int<1> : !u32i
// CIR-AFTER: %[[LOAD_ARG:.*]] = cir.load %[[ARG]] : !cir.ptr<!cir.ptr<!rec_hasField>>, !cir.ptr<!rec_hasField>
// CIR-AFTER: %[[ZERO:.*]] = cir.const #cir.int<0> : !s64i
// CIR-AFTER: %[[ARG_AS_PTR:.*]] = cir.cast bitcast %[[LOAD_ARG]] : !cir.ptr<!rec_hasField> -> !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/union.c b/clang/test/CIR/CodeGen/union.c
index ebb3e369e884c6..707b6ecf3ef8a6 100644
--- a/clang/test/CIR/CodeGen/union.c
+++ b/clang/test/CIR/CodeGen/union.c
@@ -118,6 +118,7 @@ void shouldGenerateUnionAccess(union U2 u) {
// CIR-NEXT: %[[CAST:.*]] = cir.cast bitcast %[[COERCE]] : !cir.ptr<!u64i> -> !cir.ptr<!rec_U2>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(8) init : !cir.ptr<!rec_U2>
// CIR-NEXT: cir.copy %[[CAST]] align(8) to %[[U]] align(8) : !cir.ptr<!rec_U2>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s8i
// CIR-NEXT: %[[B_PTR:.*]] = cir.get_member %[[U]][0] {name = "b"} : !cir.ptr<!rec_U2> -> !cir.ptr<!s8i>
// CIR-NEXT: cir.store{{.*}} %[[ZERO]], %[[B_PTR]] : !s8i, !cir.ptr<!s8i>
@@ -180,8 +181,10 @@ void f3(union U3 u) {
// CIR-NEXT: %[[CAST:.*]] = cir.cast bitcast %[[COERCE]] : !cir.ptr<!cir.int<u, 40>> -> !cir.ptr<!rec_U3>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(1) init : !cir.ptr<!rec_U3>
// CIR-NEXT: cir.copy %[[CAST]] align(8) to %[[U]] align(1) : !cir.ptr<!rec_U3>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s8i
// CIR-NEXT: %[[C_PTR:.*]] = cir.get_member %[[U]][0] {name = "c"} : !cir.ptr<!rec_U3> -> !cir.ptr<!cir.array<!s8i x 5>>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[IDX:.*]] = cir.const #cir.int<2> : !s64i
// CIR-NEXT: %[[ELEM_PTR:.*]] = cir.get_element %[[C_PTR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!s8i>
// CIR-NEXT: cir.store{{.*}} %[[ZERO]], %[[ELEM_PTR]] : !s8i, !cir.ptr<!s8i>
@@ -214,8 +217,10 @@ void f5(union U4 u) {
// CIR-NEXT: %[[CAST:.*]] = cir.cast bitcast %[[COERCE]] : !cir.ptr<!u64i> -> !cir.ptr<!rec_U4>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init : !cir.ptr<!rec_U4>
// CIR-NEXT: cir.copy %[[CAST]] align(8) to %[[U]] align(4) : !cir.ptr<!rec_U4>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<65> : !s32i
// CIR-NEXT: %[[CHAR_VAL:.*]] = cir.const #cir.int<65> : !s8i
// CIR-NEXT: %[[C_PTR:.*]] = cir.get_member %[[U]][0] {name = "c"} : !cir.ptr<!rec_U4> -> !cir.ptr<!cir.array<!s8i x 5>>
+// CIR-NEXT: %{{.+}} = cir.const #cir.int<4> : !s32i
// CIR-NEXT: %[[IDX:.*]] = cir.const #cir.int<4> : !s64i
// CIR-NEXT: %[[ELEM_PTR:.*]] = cir.get_element %[[C_PTR]][%[[IDX]] : !s64i] : !cir.ptr<!cir.array<!s8i x 5>> -> !cir.ptr<!s8i>
// CIR-NEXT: cir.store{{.*}} %[[CHAR_VAL]], %[[ELEM_PTR]] : !s8i, !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGen/vla.c b/clang/test/CIR/CodeGen/vla.c
index 81b4cc8827138d..03fec449cc4333 100644
--- a/clang/test/CIR/CodeGen/vla.c
+++ b/clang/test/CIR/CodeGen/vla.c
@@ -445,6 +445,8 @@ double vla_param_2d(int n, double m[n][n], int i, int j) {
// CIR: cir.store{{.*}} %[[M_ARG]], %[[M_ADDR]]
// CIR: cir.store{{.*}} %[[I_ARG]], %[[I_ADDR]]
// CIR: cir.store{{.*}} %[[J_ARG]], %[[J_ADDR]]
+// CIR: %[[N_OUTER:.*]] = cir.load{{.*}} %[[N_ADDR]]
+// CIR: %{{.+}} = cir.cast integral %[[N_OUTER]] : !s32i -> !u64i
// CIR: %[[N:.*]] = cir.load{{.*}} %[[N_ADDR]]
// CIR: %[[VLA_SIZE:.*]] = cir.cast integral %[[N]] : !s32i -> !u64i
// CIR: %[[M:.*]] = cir.load{{.*}} %[[M_ADDR]]
@@ -467,6 +469,8 @@ double vla_param_2d(int n, double m[n][n], int i, int j) {
// LLVM: store ptr %[[M_ARG]], ptr %[[M_ADDR]]
// LLVM: store i32 %[[I_ARG]], ptr %[[I_ADDR]]
// LLVM: store i32 %[[J_ARG]], ptr %[[J_ADDR]]
+// LLVM: %[[N_OUTER:.*]] = load i32, ptr %[[N_ADDR]]
+// LLVM: %{{.+}} = sext i32 %[[N_OUTER]] to i64
// LLVM: %[[N:.*]] = load i32, ptr %[[N_ADDR]]
// LLVM: %[[VLA_SIZE:.*]] = sext i32 %[[N]] to i64
// LLVM: %[[M:.*]] = load ptr, ptr %[[M_ADDR]]
@@ -512,12 +516,14 @@ void complex_vla_cast(int n) {
// CIR: %[[LEN_ADDR:.*]] = cir.alloca "n" {{.*}} init : !cir.ptr<!s32i>
// CIR: %[[SAVED_STACK:.*]] = cir.alloca "saved_stack" {{.*}} : !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.store %{{.*}}, %[[LEN_ADDR]] : !s32i, !cir.ptr<!s32i>
+// CIR: %[[LEN_UNUSED:.*]] = cir.load {{.*}} %[[LEN_ADDR]] : !cir.ptr<!s32i>, !s32i
+// CIR: %{{.+}} = cir.cast integral %[[LEN_UNUSED]] : !s32i -> !u64i
// CIR: %[[LEN:.*]] = cir.load {{.*}} %[[LEN_ADDR]] : !cir.ptr<!s32i>, !s32i
// CIR: %[[LEN_SIZE_T:.*]] = cir.cast integral %[[LEN]] : !s32i -> !u64i
// CIR: %[[STACK_PTR:.*]] = cir.stacksave : !cir.ptr<!u8i>
// CIR: cir.store {{.*}} %[[STACK_PTR]], %[[SAVED_STACK]] : !cir.ptr<!u8i>, !cir.ptr<!cir.ptr<!u8i>>
// CIR: cir.cleanup.scope {
-// CIR: %[[ArR:.*]] = cir.alloca "arr" {{.*}} size(%3) : !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[ArR:.*]] = cir.alloca "arr" {{.*}} size(%[[LEN_SIZE_T]]) : !cir.ptr<!cir.complex<!cir.float>>
// CIR: cir.yield
// CIR: } cleanup normal {
// CIR: %[[STACK_RESTORE_PTR:.*]] = cir.load {{.*}} %[[SAVED_STACK]] : !cir.ptr<!cir.ptr<!u8i>>, !cir.ptr<!u8i>
@@ -529,6 +535,8 @@ void complex_vla_cast(int n) {
// LLVM: %[[LEN_ADDR:.*]] = alloca i32, align 4
// LLVM: %[[SAVED_STACK:.*]] = alloca ptr, align 8
// LLVM: store i32 %{{.*}}, ptr %[[LEN_ADDR]], align 4
+// LLVM: %[[LEN_UNUSED:.*]] = load i32, ptr %[[LEN_ADDR]], align 4
+// LLVM: %{{.+}} = sext i32 %[[LEN_UNUSED]] to i64
// LLVM: %[[LEN:.*]] = load i32, ptr %[[LEN_ADDR]], align 4
// LLVM: %[[LEN_SIZE_T:.*]] = sext i32 %[[LEN]] to i64
// LLVM: %[[STACK_PTR:.*]] = call ptr @llvm.stacksave.p0()
diff --git a/clang/test/CIR/CodeGen/void-value-expr.cpp b/clang/test/CIR/CodeGen/void-value-expr.cpp
index fadbb05464880c..a012def049ecac 100644
--- a/clang/test/CIR/CodeGen/void-value-expr.cpp
+++ b/clang/test/CIR/CodeGen/void-value-expr.cpp
@@ -58,6 +58,8 @@ void ternaryCheap(bool b) {
// CIR: %[[ARG:.*]] = cir.alloca {{.*}} : !cir.ptr<!cir.bool>
// CIR: cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR-NEXT: cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.bool>, !cir.bool
+// CIR-NEXT: cir.const #cir.int<0> : !s32i
+// CIR-NEXT: cir.const #cir.int<1> : !s32i
// CIR-NEXT: cir.load{{.*}}%[[ARG]] : !cir.ptr<!cir.bool>, !cir.bool
// CIR-NEXT: cir.return
// LLVM-LABEL: define{{.*}} void @_Z12ternaryCheapb
diff --git a/clang/test/CIR/CodeGenCXX/new-array-init.cpp b/clang/test/CIR/CodeGenCXX/new-array-init.cpp
index 183c9aac2a3dbf..3aff6ec9ff246a 100644
--- a/clang/test/CIR/CodeGenCXX/new-array-init.cpp
+++ b/clang/test/CIR/CodeGenCXX/new-array-init.cpp
@@ -388,6 +388,7 @@ void string_nonconst_paren_extra_paren(int n) {
// CIR-LABEL: cir.func {{.*}}@_Z12string_exactv()
// LLVM-LABEL: define{{.*}} void @_Z12string_exactv
void string_exact() {
+ // CIR: %{{.+}} = cir.const #cir.int<4> : !u64i
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_CAST:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
@@ -404,6 +405,7 @@ void string_exact() {
// CIR-LABEL: cir.func {{.*}}@_Z18string_exact_parenv()
// LLVM-LABEL: define{{.*}} void @_Z18string_exact_parenv
void string_exact_paren() {
+ // CIR: %{{.+}} = cir.const #cir.int<4> : !u64i
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_CAST:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
@@ -420,6 +422,7 @@ void string_exact_paren() {
// CIR-LABEL: cir.func {{.*}}@_Z28string_exact_paren_extensionv()
// LLVM-LABEL: define{{.*}} void @_Z28string_exact_paren_extensionv
void string_exact_paren_extension() {
+ // CIR: %{{.+}} = cir.const #cir.int<4> : !u64i
// CIR: %[[SIZE:.*]] = cir.const #cir.int<4> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_CAST:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
@@ -436,6 +439,7 @@ void string_exact_paren_extension() {
// CIR-LABEL: cir.func {{.*}}@_Z17string_sufficientv()
// LLVM-LABEL: define{{.*}} void @_Z17string_sufficientv
void string_sufficient() {
+ // CIR: %{{.+}} = cir.const #cir.int<15> : !u64i
// CIR: %[[SIZE:.*]] = cir.const #cir.int<15> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_CAST:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
@@ -452,6 +456,7 @@ void string_sufficient() {
// CIR-LABEL: cir.func {{.*}}@_Z23string_sufficient_parenv()
// LLVM-LABEL: define{{.*}} void @_Z23string_sufficient_parenv
void string_sufficient_paren() {
+ // CIR: %{{.+}} = cir.const #cir.int<15> : !u64i
// CIR: %[[SIZE:.*]] = cir.const #cir.int<15> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_CAST:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
@@ -637,6 +642,7 @@ void unknown_bound() {
// CIR-LABEL: cir.func {{.*}}@_Z20unknown_bound_stringv()
// LLVM-LABEL: define{{.*}} void @_Z20unknown_bound_stringv
void unknown_bound_string() {
+ // CIR: %{{.+}} = cir.const #cir.int<6> : !u64i
// CIR: %[[SIZE:.*]] = cir.const #cir.int<6> : !u64i
// CIR: %[[ALLOC:.*]] = cir.call @_Znam(%[[SIZE]]) {allocsize = array<i32: 0>, builtin, memory_effects = #cir.memory_effects<other = none, arg_mem = none, inaccessible_mem = readwrite, errno_mem = write, target_mem0 = none, target_mem1 = none>} : (!u64i {llvm.noundef}) -> (!cir.ptr<!void> {llvm.noalias, llvm.nonnull, llvm.noundef})
// CIR: %[[ALLOC_CHAR:.*]] = cir.cast bitcast %[[ALLOC]] : !cir.ptr<!void> -> !cir.ptr<!s8i>
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-copy.c b/clang/test/CIR/CodeGenOpenACC/combined-copy.c
index 828ee49b2a29ec..de47d24db227f6 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-copy.c
+++ b/clang/test/CIR/CodeGenOpenACC/combined-copy.c
@@ -1087,6 +1087,7 @@ void copy_member_of_array_element_member() {
#pragma acc parallel loop copy(outer.inner[2].b)
for(int i = 0; i < 5; ++i);
// CHECK-NEXT: %[[GETINNER:.*]] = cir.get_member %[[OUTER]][0] {name = "inner"} : !cir.ptr<!rec_OuterTy> -> !cir.ptr<!cir.array<!rec_InnerTy x 4>>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[TWO:.*]] = cir.const #cir.int<2> : !s64i
// CHECK-NEXT: %[[GET_ELT:.*]] = cir.get_element %[[GETINNER]][%[[TWO]] : !s64i] : !cir.ptr<!cir.array<!rec_InnerTy x 4>> -> !cir.ptr<!rec_InnerTy>
// CHECK-NEXT: %[[GETB:.*]] = cir.get_member %[[GET_ELT]][1] {name = "b"} : !cir.ptr<!rec_InnerTy> -> !cir.ptr<!s32i>
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
index c60bc7638d0b23..b1512dd25c3fb1 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c
@@ -127,6 +127,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -141,6 +142,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -155,6 +157,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -169,6 +172,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.double
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -185,6 +189,7 @@ void acc_compute() {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RHS_CAST:.*]] = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_CAST]], %[[RHS_CAST]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RES_CAST:.*]] = cir.cast bool_to_int %[[RESULT]] : !cir.bool -> !s32i
@@ -215,6 +220,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -229,6 +235,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -243,6 +250,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -257,6 +265,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.double
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -273,6 +282,7 @@ void acc_compute() {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RHS_CAST:.*]] = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_CAST]], %[[RHS_CAST]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RES_CAST:.*]] = cir.cast bool_to_int %[[RESULT]] : !cir.bool -> !s32i
@@ -466,13 +476,16 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_GET_B:.*]] = cir.get_member %[[LHSARG]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[RHS_GET_B:.*]] = cir.get_member %[[RHSARG]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[LHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[LHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_LOAD]], true {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[RHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.yield %[[RHS_LOAD]] : !cir.bool
// CHECK-NEXT: }, false {
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
// CHECK-NEXT: cir.yield %[[FALSE]]
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[TERNARY]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.store {{.*}} %[[TERNARY]], %[[LHS_GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: }
@@ -553,13 +566,16 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_GET_B:.*]] = cir.get_member %[[LHSARG]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[RHS_GET_B:.*]] = cir.get_member %[[RHSARG]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[LHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[LHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_LOAD]], true {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
// CHECK-NEXT: cir.yield %[[TRUE]]
// CHECK-NEXT: }, false {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[RHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.yield %[[RHS_LOAD]] : !cir.bool
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[TERNARY]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.store {{.*}} %[[TERNARY]], %[[LHS_GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators>
// CHECK-NEXT: }
@@ -734,6 +750,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -748,6 +765,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -762,6 +780,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -776,6 +795,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.double
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -792,6 +812,7 @@ void acc_compute() {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RHS_CAST:.*]] = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_CAST]], %[[RHS_CAST]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RES_CAST:.*]] = cir.cast bool_to_int %[[RESULT]] : !cir.bool -> !s32i
@@ -844,6 +865,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -858,6 +880,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -872,6 +895,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -886,6 +910,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.double
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -902,6 +927,7 @@ void acc_compute() {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RHS_CAST:.*]] = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_CAST]], %[[RHS_CAST]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RES_CAST:.*]] = cir.cast bool_to_int %[[RESULT]] : !cir.bool -> !s32i
@@ -1187,13 +1213,16 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_GET_B:.*]] = cir.get_member %[[LHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[RHS_GET_B:.*]] = cir.get_member %[[RHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[LHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[LHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_LOAD]], true {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[RHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.yield %[[RHS_LOAD]] : !cir.bool
// CHECK-NEXT: }, false {
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
// CHECK-NEXT: cir.yield %[[FALSE]]
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[TERNARY]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.store {{.*}} %[[TERNARY]], %[[LHS_GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
//
// CHECK-NEXT: cir.yield
@@ -1298,13 +1327,16 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_GET_B:.*]] = cir.get_member %[[LHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[RHS_GET_B:.*]] = cir.get_member %[[RHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[LHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[LHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_LOAD]], true {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
// CHECK-NEXT: cir.yield %[[TRUE]]
// CHECK-NEXT: }, false {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[RHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.yield %[[RHS_LOAD]] : !cir.bool
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[TERNARY]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.store {{.*}} %[[TERNARY]], %[[LHS_GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
//
// CHECK-NEXT: cir.yield
@@ -1600,6 +1632,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1614,6 +1647,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1628,6 +1662,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1642,6 +1677,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.double
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1658,6 +1694,7 @@ void acc_compute() {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RHS_CAST:.*]] = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_CAST]], %[[RHS_CAST]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RES_CAST:.*]] = cir.cast bool_to_int %[[RESULT]] : !cir.bool -> !s32i
@@ -1752,6 +1789,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1766,6 +1804,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1780,6 +1819,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1794,6 +1834,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.double
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.double>, !cir.double
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -1810,6 +1851,7 @@ void acc_compute() {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[GET_MEM_RHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RHS_CAST:.*]] = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_CAST]], %[[RHS_CAST]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[GET_MEM_LHS]] : !cir.ptr<!cir.bool>, !cir.bool
// CHECK-NEXT: %[[RES_CAST:.*]] = cir.cast bool_to_int %[[RESULT]] : !cir.bool -> !s32i
@@ -2228,13 +2270,16 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_GET_B:.*]] = cir.get_member %[[LHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[RHS_GET_B:.*]] = cir.get_member %[[RHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[LHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[LHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_LOAD]], true {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[RHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.yield %[[RHS_LOAD]] : !cir.bool
// CHECK-NEXT: }, false {
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
// CHECK-NEXT: cir.yield %[[FALSE]]
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[TERNARY]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.store {{.*}} %[[TERNARY]], %[[LHS_GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
//
// CHECK-NEXT: cir.yield
@@ -2377,13 +2422,16 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_GET_B:.*]] = cir.get_member %[[LHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[RHS_GET_B:.*]] = cir.get_member %[[RHS_STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool>
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load{{.*}} %[[LHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[LHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[LHS_LOAD]], true {
// CHECK-NEXT: %[[TRUE:.*]] = cir.const #true
// CHECK-NEXT: cir.yield %[[TRUE]]
// CHECK-NEXT: }, false {
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load{{.*}} %[[RHS_GET_B]] : !cir.ptr<!cir.bool>, !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[RHS_LOAD]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.yield %[[RHS_LOAD]] : !cir.bool
// CHECK-NEXT: }) : (!cir.bool) -> !cir.bool
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[TERNARY]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.store {{.*}} %[[TERNARY]], %[[LHS_GET_B]] : !cir.bool, !cir.ptr<!cir.bool>
//
// CHECK-NEXT: cir.yield
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
index 480e9ac9d8348c..0cd06a1445dd69 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c
@@ -49,6 +49,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHSARG]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -73,6 +74,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!cir.float>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHSARG]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -239,6 +241,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -284,6 +287,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -581,6 +585,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -652,6 +657,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !cir.float
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHS_STRIDE]] : !cir.ptr<!cir.float>, !cir.float
// CHECK-NEXT: cir.yield %[[RESULT]]
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
index 408925699d3c95..9cf2f429800f27 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-int.c
@@ -50,6 +50,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!s32i>
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!s32i>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHSARG]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -73,6 +74,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!s32i>
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!s32i>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHSARG]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -289,6 +291,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -334,6 +337,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -743,6 +747,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -814,6 +819,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !s32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHS_STRIDE]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: cir.yield %[[RESULT]]
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
index 2cae7275c42c59..faddafad183a70 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
+++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-unsigned-int.c
@@ -50,6 +50,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!u32i>
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!u32i>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHSARG]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -73,6 +74,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHSARG]] : !cir.ptr<!u32i>
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHSARG]] : !cir.ptr<!u32i>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHSARG]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -290,6 +292,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -335,6 +338,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -746,6 +750,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[RHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
@@ -817,6 +822,7 @@ void acc_compute() {
// CHECK-NEXT: %[[LHS_LOAD:.*]] = cir.load {{.*}} %[[LHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[RHS_LOAD:.*]] = cir.load {{.*}} %[[RHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp lt %[[LHS_LOAD]], %[[RHS_LOAD]] : !u32i
+// CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[TERNARY:.*]] = cir.ternary(%[[CMP]], true {
// CHECK-NEXT: %[[RESULT:.*]] = cir.load{{.*}} %[[LHS_STRIDE]] : !cir.ptr<!u32i>, !u32i
// CHECK-NEXT: cir.yield %[[RESULT]]
diff --git a/clang/test/CIR/CodeGenOpenACC/data.c b/clang/test/CIR/CodeGenOpenACC/data.c
index 2e7b08f0551637..9d67779806d7bd 100644
--- a/clang/test/CIR/CodeGenOpenACC/data.c
+++ b/clang/test/CIR/CodeGenOpenACC/data.c
@@ -107,6 +107,7 @@ void acc_data(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES]] : !cir.bool to i1
// CHECK-NEXT: acc.data if(%[[CONV_CAST]]) {
// CHECK-NEXT: acc.terminator
diff --git a/clang/test/CIR/CodeGenOpenACC/enter-data.c b/clang/test/CIR/CodeGenOpenACC/enter-data.c
index 4b1f427f89a5d6..96fbb66adf243f 100644
--- a/clang/test/CIR/CodeGenOpenACC/enter-data.c
+++ b/clang/test/CIR/CodeGenOpenACC/enter-data.c
@@ -70,6 +70,7 @@ void acc_data(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: %[[COPYIN1:.*]] = acc.copyin varPtr(%[[PARM]] : !cir.ptr<!s32i>) structured(false) name("parmVar") -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.enter_data if(%[[CMP_CAST]]) dataOperands(%[[COPYIN1]] : !cir.ptr<!s32i>)
@@ -78,6 +79,7 @@ void acc_data(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: %[[COPYIN1:.*]] = acc.copyin varPtr(%[[PARM]] : !cir.ptr<!s32i>) async structured(false) name("parmVar") -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.enter_data if(%[[CMP_CAST]]) async dataOperands(%[[COPYIN1]] : !cir.ptr<!s32i>)
@@ -86,6 +88,7 @@ void acc_data(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[PARM_CAST:.*]] = cir.builtin_int_cast %[[PARM_LOAD]]
diff --git a/clang/test/CIR/CodeGenOpenACC/exit-data.c b/clang/test/CIR/CodeGenOpenACC/exit-data.c
index c895846770a3c5..6c9d0c7debe15d 100644
--- a/clang/test/CIR/CodeGenOpenACC/exit-data.c
+++ b/clang/test/CIR/CodeGenOpenACC/exit-data.c
@@ -73,6 +73,7 @@ void acc_data(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: %[[GDP:.*]] = acc.getdeviceptr varPtr(%[[PARM]] : !cir.ptr<!s32i>) dataClause(acc_copyout) structured(false) name("parmVar") -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.exit_data if(%[[CMP_CAST]]) dataOperands(%[[GDP]] : !cir.ptr<!s32i>)
@@ -82,6 +83,7 @@ void acc_data(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: %[[GDP:.*]] = acc.getdeviceptr varPtr(%[[PARM]] : !cir.ptr<!s32i>) async dataClause(acc_copyout) structured(false) name("parmVar") -> !cir.ptr<!s32i>
// CHECK-NEXT: acc.exit_data if(%[[CMP_CAST]]) async dataOperands(%[[GDP]] : !cir.ptr<!s32i>)
@@ -91,6 +93,7 @@ void acc_data(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[PARM_CAST:.*]] = cir.builtin_int_cast %[[PARM_LOAD]]
diff --git a/clang/test/CIR/CodeGenOpenACC/kernels.c b/clang/test/CIR/CodeGenOpenACC/kernels.c
index 2111643cb9b8f3..8773f7cff2345b 100644
--- a/clang/test/CIR/CodeGenOpenACC/kernels.c
+++ b/clang/test/CIR/CodeGenOpenACC/kernels.c
@@ -87,6 +87,7 @@ void acc_kernels(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES]] : !cir.bool to i1
// CHECK-NEXT: acc.kernels if(%[[CONV_CAST]]) {
// CHECK-NEXT: acc.terminator
@@ -97,10 +98,12 @@ void acc_kernels(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES_IF:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES_IF]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST_IF:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES_IF]] : !cir.bool to i1
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[TWO_LITERAL:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[EQ_RES_SELF:.*]] = cir.cmp eq %[[COND_LOAD]], %[[TWO_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES_SELF]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST_SELF:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES_SELF]] : !cir.bool to i1
// CHECK-NEXT: acc.kernels self(%[[CONV_CAST_SELF]]) if(%[[CONV_CAST_IF]]) {
// CHECK-NEXT: acc.terminator
diff --git a/clang/test/CIR/CodeGenOpenACC/parallel.c b/clang/test/CIR/CodeGenOpenACC/parallel.c
index 28c9f5127b9890..bc5227e00d1fe2 100644
--- a/clang/test/CIR/CodeGenOpenACC/parallel.c
+++ b/clang/test/CIR/CodeGenOpenACC/parallel.c
@@ -86,6 +86,7 @@ void acc_parallel(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES]] : !cir.bool to i1
// CHECK-NEXT: acc.parallel if(%[[CONV_CAST]]) {
// CHECK-NEXT: acc.yield
@@ -96,10 +97,12 @@ void acc_parallel(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES_IF:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES_IF]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST_IF:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES_IF]] : !cir.bool to i1
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[TWO_LITERAL:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[EQ_RES_SELF:.*]] = cir.cmp eq %[[COND_LOAD]], %[[TWO_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES_SELF]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST_SELF:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES_SELF]] : !cir.bool to i1
// CHECK-NEXT: acc.parallel self(%[[CONV_CAST_SELF]]) if(%[[CONV_CAST_IF]]) {
// CHECK-NEXT: acc.yield
diff --git a/clang/test/CIR/CodeGenOpenACC/serial.c b/clang/test/CIR/CodeGenOpenACC/serial.c
index e3098f63f242ae..b69fccd58b7009 100644
--- a/clang/test/CIR/CodeGenOpenACC/serial.c
+++ b/clang/test/CIR/CodeGenOpenACC/serial.c
@@ -87,6 +87,7 @@ void acc_serial(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES]] : !cir.bool to i1
// CHECK-NEXT: acc.serial if(%[[CONV_CAST]]) {
// CHECK-NEXT: acc.yield
@@ -97,10 +98,12 @@ void acc_serial(int cond) {
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[ONE_LITERAL:.*]] = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[EQ_RES_IF:.*]] = cir.cmp eq %[[COND_LOAD]], %[[ONE_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES_IF]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST_IF:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES_IF]] : !cir.bool to i1
// CHECK-NEXT: %[[COND_LOAD:.*]] = cir.load{{.*}} %[[COND]] : !cir.ptr<!s32i>, !s32i
// CHECK-NEXT: %[[TWO_LITERAL:.*]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[EQ_RES_SELF:.*]] = cir.cmp eq %[[COND_LOAD]], %[[TWO_LITERAL]] : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[EQ_RES_SELF]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CONV_CAST_SELF:.*]] = builtin.unrealized_conversion_cast %[[EQ_RES_SELF]] : !cir.bool to i1
// CHECK-NEXT: acc.serial self(%[[CONV_CAST_SELF]]) if(%[[CONV_CAST_IF]]) {
// CHECK-NEXT: acc.yield
diff --git a/clang/test/CIR/CodeGenOpenACC/update.c b/clang/test/CIR/CodeGenOpenACC/update.c
index 82fc72ffb924be..fb7955b837d6bc 100644
--- a/clang/test/CIR/CodeGenOpenACC/update.c
+++ b/clang/test/CIR/CodeGenOpenACC/update.c
@@ -70,6 +70,7 @@ void acc_update(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: acc.update if(%[[CMP_CAST]]) dataOperands(%[[GDP1]] : !cir.ptr<!s32i>)
// CHECK-NEXT: acc.update_host accPtr(%[[GDP1]] : !cir.ptr<!s32i>) to varPtr(%[[PARM]] : !cir.ptr<!s32i>) dataClause(acc_update_self) structured(false) name("parmVar")
@@ -78,6 +79,7 @@ void acc_update(int parmVar, int *ptrParmVar) {
// CHECK-NEXT: %[[PARM_LOAD:.*]] = cir.load{{.*}} %[[PARM]]
// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1>
// CHECK-NEXT: %[[CMP:.*]] = cir.cmp eq %[[PARM_LOAD]], %[[ONE_CONST]]
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[CMP]] : !cir.bool -> !s32i
// CHECK-NEXT: %[[CMP_CAST:.*]] = builtin.unrealized_conversion_cast %[[CMP]]
// CHECK-NEXT: acc.update if(%[[CMP_CAST]]) dataOperands(%[[GDP1]] : !cir.ptr<!s32i>) ifPresent
// CHECK-NEXT: acc.update_host accPtr(%[[GDP1]] : !cir.ptr<!s32i>) to varPtr(%[[PARM]] : !cir.ptr<!s32i>) dataClause(acc_update_self) structured(false) name("parmVar")
diff --git a/clang/test/CIR/CodeGenSYCL/global-address-space.cpp b/clang/test/CIR/CodeGenSYCL/global-address-space.cpp
index f2220474615f98..e7f4419609ace0 100644
--- a/clang/test/CIR/CodeGenSYCL/global-address-space.cpp
+++ b/clang/test/CIR/CodeGenSYCL/global-address-space.cpp
@@ -55,6 +55,7 @@ int i;
// CIR: cir.return
// LLVM-LABEL: define {{.*}} ptr addrspace(2) @_Z15addr_explicit_cv()
+// LLVM-CIR: %{{.+}} = addrspacecast ptr %{{.+}} to ptr addrspace(4)
// LLVM-NOT: addrspacecast
// LLVM: ret ptr addrspace(2)
diff --git a/clang/test/CIR/Transforms/bit.cir b/clang/test/CIR/Transforms/bit.cir
index c20448e74a0266..40a9e0889a4680 100644
--- a/clang/test/CIR/Transforms/bit.cir
+++ b/clang/test/CIR/Transforms/bit.cir
@@ -11,6 +11,7 @@ module {
cir.return %1 : !s32i
}
// CHECK-LABEL: @fold_clrsb
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<30> : !s32i
// CHECK-NEXT: cir.return %[[R]] : !s32i
// CHECK-NEXT: }
@@ -21,6 +22,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_clz
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<31> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -31,6 +33,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_clz_zero_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.poison : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -41,6 +44,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_clz_zero_no_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<32> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -51,6 +55,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_ctz
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -61,6 +66,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_ctz_zero_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.poison : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -71,6 +77,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_ctz_zero_no_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<32> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -82,6 +89,7 @@ module {
cir.return %1 : !s32i
}
// CHECK-LABEL: @fold_ffs
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<40> : !s32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<4> : !s32i
// CHECK-NEXT: cir.return %[[R]] : !s32i
// CHECK-NEXT: }
@@ -92,6 +100,7 @@ module {
cir.return %1 : !s32i
}
// CHECK-LABEL: @fold_ffs_zero
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.return %[[R]] : !s32i
// CHECK-NEXT: }
@@ -104,6 +113,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_parity
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3735928559> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -116,6 +126,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_popcount
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3735928559> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<24> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -127,6 +138,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_bitreverse
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3735928559> : !u32i
// 4152210811 is 0b1111_0111_0111_1101_1011_0101_0111_1011
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<4152210811> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
@@ -138,6 +150,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_byte_swap
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3735928559> : !u32i
// 4022250974 is 0xefbeadde
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<4022250974> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
@@ -149,6 +162,7 @@ module {
cir.return %1 : !s32i
}
// CHECK-LABEL: @fold_input_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.poison : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.poison : !s32i
// CHECK-NEXT: cir.return %[[P]] : !s32i
// CHECK-NEXT: }
@@ -159,6 +173,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_rotate_input_all_zeros
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<0> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -170,6 +185,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_rotate_input_all_ones
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -181,6 +197,7 @@ module {
}
// CHECK-LABEL: @fold_rotate_zero_amount
// CHECK-SAME: (%[[R:.+]]: !u32i)
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<32> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
// CHECK-NEXT: }
@@ -192,6 +209,8 @@ module {
cir.return %2 : !u32i
}
// CHECK-LABEL: @fold_rotate_left
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3735928559> : !u32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<8> : !u32i
// 2914971614 is 0b1010_1101_1011_1110_1110_1111_1101_1110
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<2914971614> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
@@ -205,6 +224,8 @@ module {
cir.return %2 : !u32i
}
// CHECK-LABEL: @fold_rotate_right
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3735928559> : !u32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<8> : !u32i
// 4260027374 is 0b1110_1111_1101_1110_1010_1101_1011_1110
// CHECK-NEXT: %[[R:.+]] = cir.const #cir.int<4024348094> : !u32i
// CHECK-NEXT: cir.return %[[R]] : !u32i
@@ -216,6 +237,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_rotate_input_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.poison : !u32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.poison : !u32i
// CHECK-NEXT: cir.return %[[P]] : !u32i
// CHECK-NEXT: }
@@ -226,6 +248,7 @@ module {
cir.return %1 : !u32i
}
// CHECK-LABEL: @fold_rotate_amount_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.poison : !u32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.poison : !u32i
// CHECK-NEXT: cir.return %[[P]] : !u32i
// CHECK-NEXT: }
@@ -237,6 +260,7 @@ module {
}
// CHECK-LABEL: @involution_bitreverse
// CHECK-SAME: (%[[X:.+]]: !u32i)
+ // CHECK-NEXT: %{{.+}} = cir.bitreverse %[[X]] : !u32i
// CHECK-NEXT: cir.return %[[X]] : !u32i
// CHECK-NEXT: }
@@ -247,6 +271,7 @@ module {
}
// CHECK-LABEL: @involution_byte_swap
// CHECK-SAME: (%[[X:.+]]: !u32i)
+ // CHECK-NEXT: %{{.+}} = cir.byte_swap %[[X]] : !u32i
// CHECK-NEXT: cir.return %[[X]] : !u32i
// CHECK-NEXT: }
}
diff --git a/clang/test/CIR/Transforms/builtin-int-cast-fold.cir b/clang/test/CIR/Transforms/builtin-int-cast-fold.cir
index 0b18a84218c0d1..47dcb8e54f32e0 100644
--- a/clang/test/CIR/Transforms/builtin-int-cast-fold.cir
+++ b/clang/test/CIR/Transforms/builtin-int-cast-fold.cir
@@ -13,6 +13,7 @@ module {
}
// CHECK: cir.func{{.*}} @roundtrip(%[[ARG:.+]]: !s32i) -> !s32i {
+ // CHECK-NEXT: %{{.+}} = cir.builtin_int_cast %[[ARG]] : !s32i -> i32
// CHECK-NEXT: cir.return %[[ARG]] : !s32i
// CHECK-NEXT: }
diff --git a/clang/test/CIR/Transforms/canonicalize-dead-code.cir b/clang/test/CIR/Transforms/canonicalize-dead-code.cir
new file mode 100644
index 00000000000000..74c68a4e064015
--- /dev/null
+++ b/clang/test/CIR/Transforms/canonicalize-dead-code.cir
@@ -0,0 +1,42 @@
+// RUN: cir-opt %s -cir-canonicalize=test-convergence -o - | FileCheck %s
+
+!s32i = !cir.int<s, 32>
+
+module {
+ // Dead operations are kept, while folding still replaces the uses of a
+ // foldable operation.
+ cir.func @dead_ops(%arg0: !cir.ptr<!s32i>) -> !s32i {
+ %0 = cir.alloca "unused" align(4) : !cir.ptr<!s32i>
+ %1 = cir.load %arg0 : !cir.ptr<!s32i>, !s32i
+ %2 = cir.const #cir.int<1> : !s32i
+ %3 = cir.add %1, %2 : !s32i
+ %4 = cir.minus %2 : !s32i
+ cir.return %4 : !s32i
+ }
+
+ // CHECK-LABEL: cir.func @dead_ops
+ // CHECK-NEXT: cir.alloca "unused"
+ // CHECK-NEXT: %[[LOAD:.*]] = cir.load %arg0
+ // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
+ // CHECK-NEXT: cir.add %[[LOAD]], %[[ONE]] : !s32i
+ // CHECK-NEXT: %[[NEG:.*]] = cir.const #cir.int<-1> : !s32i
+ // CHECK-NEXT: cir.return %[[NEG]] : !s32i
+
+ // A block that starts with a label is reached through cir.goto only, which
+ // is not a CFG edge, so it must not be erased as unreachable.
+ cir.func @goto_target(%arg0: !cir.bool) {
+ cir.brcond %arg0 ^bb1, ^bb2
+ ^bb1:
+ cir.goto "L"
+ ^bb2:
+ cir.return
+ ^bb3:
+ cir.label "L"
+ cir.return
+ }
+
+ // CHECK-LABEL: cir.func @goto_target
+ // CHECK: cir.goto "L"
+ // CHECK: cir.label "L"
+ // CHECK-NEXT: cir.return
+}
diff --git a/clang/test/CIR/Transforms/canonicalize.cir b/clang/test/CIR/Transforms/canonicalize.cir
index a65df32833f196..fc2027c0df827b 100644
--- a/clang/test/CIR/Transforms/canonicalize.cir
+++ b/clang/test/CIR/Transforms/canonicalize.cir
@@ -72,8 +72,7 @@ module {
cir.return
}
// CHECK: cir.func{{.*}} @dead_switch() {
- // CHECK-NOT: %[[Z:.*]] = cir.const #cir.int<0> : !s32i
- // CHECK-NOT: cir.switch
+ // CHECK-NEXT: cir.const #cir.int<0> : !s32i
// CHECK-NEXT: cir.return
// CHECK-NEXT: }
@@ -83,6 +82,7 @@ module {
cir.return %1 : !cir.bool
}
// CHECK: cir.func{{.*}} @unary_not_not(%arg0: !cir.bool) -> !cir.bool
+ // CHECK-NEXT: %{{.+}} = cir.not %arg0 : !cir.bool
// CHECK-NEXT: cir.return %arg0 : !cir.bool
cir.func @unary_poison() -> !s32i {
@@ -91,6 +91,7 @@ module {
cir.return %1 : !s32i
}
// CHECK: @unary_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.poison : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.poison : !s32i
// CHECK-NEXT: cir.return %[[P]] : !s32i
// CHECK-NEXT: }
@@ -101,6 +102,7 @@ module {
cir.return %1 : !cir.bool
}
// CHECK: cir.func{{.*}} @unary_not_true() -> !cir.bool
+ // CHECK-NEXT: %{{.+}} = cir.const #true
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #false
// CHECK-NEXT: cir.return %[[FALSE]] : !cir.bool
@@ -110,6 +112,7 @@ module {
cir.return %1 : !cir.bool
}
// CHECK: cir.func{{.*}} @unary_not_false() -> !cir.bool
+ // CHECK-NEXT: %{{.+}} = cir.const #false
// CHECK-NEXT: %[[FALSE:.*]] = cir.const #true
// CHECK-NEXT: cir.return %[[FALSE]] : !cir.bool
@@ -119,6 +122,7 @@ module {
cir.return %1 : !s32i
}
// CHECK: cir.func{{.*}} @unary_not_int() -> !s32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.int<-2> : !s32i
// CHECK-NEXT: cir.return %[[CONST]] : !s32i
@@ -128,6 +132,7 @@ module {
cir.return %1 : !u32i
}
// CHECK: cir.func{{.*}} @unary_not_uint() -> !u32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.int<4294967294> : !u32i
// CHECK-NEXT: cir.return %[[CONST]] : !u32i
@@ -137,6 +142,7 @@ module {
cir.return %1 : !s32i
}
// CHECK: cir.func{{.*}} @unary_minus_int() -> !s32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: cir.return %[[CONST]] : !s32i
@@ -146,6 +152,7 @@ module {
cir.return %1 : !u32i
}
// CHECK: cir.func{{.*}} @unary_minus_uint() -> !u32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !u32i
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.int<4294967295> : !u32i
// CHECK-NEXT: cir.return %[[CONST]] : !u32i
@@ -155,6 +162,7 @@ module {
cir.return %1 : !cir.float
}
// CHECK: cir.func{{.*}} @unary_fneg_float() -> !cir.float
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.fp<1.100000e+00> : !cir.float
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.fp<-1.100000e+00> : !cir.float
// CHECK-NEXT: cir.return %[[CONST]] : !cir.float
@@ -164,6 +172,7 @@ module {
cir.return %1 : !cir.double
}
// CHECK: cir.func{{.*}} @unary_fneg_double() -> !cir.double
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.fp<1.100000e+00> : !cir.double
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.fp<-1.100000e+00> : !cir.double
// CHECK-NEXT: cir.return %[[CONST]] : !cir.double
@@ -173,6 +182,7 @@ module {
cir.return %1 : !cir.float
}
// CHECK: cir.func{{.*}} @unary_fneg_nan() -> !cir.float
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.fp<0x7F800000> : !cir.float
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.fp<0xFF800000> : !cir.float
// CHECK-NEXT: cir.return %[[CONST]] : !cir.float
@@ -182,6 +192,7 @@ module {
cir.return %1 : !cir.float
}
// CHECK: cir.func{{.*}} @unary_fneg_neg_nan() -> !cir.float
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.fp<0xFF800000> : !cir.float
// CHECK-NEXT: %[[CONST:.*]] = cir.const #cir.fp<0x7F800000> : !cir.float
// CHECK-NEXT: cir.return %[[CONST]] : !cir.float
@@ -191,6 +202,7 @@ module {
cir.return %1 : !cir.bool
}
// CHECK: cir.func{{.*}} @cast1(%[[ARG0:.*]]: !cir.bool) -> !cir.bool
+ // CHECK-NEXT: %{{.+}} = cir.cast bool_to_int %[[ARG0]] : !cir.bool -> !s32i
// CHECK-NEXT: cir.return %[[ARG0]] : !cir.bool
cir.func @cast2(%arg0: !s32i) -> !cir.bool {
@@ -202,6 +214,8 @@ module {
}
// CHECK: cir.func{{.*}} @cast2(%[[ARG0:.*]]: !s32i) -> !cir.bool
// CHECK-NEXT: %[[CAST:.*]] = cir.cast int_to_bool %[[ARG0]] : !s32i -> !cir.bool
+ // CHECK-NEXT: %[[CAST2:.*]] = cir.cast bool_to_int %[[CAST]] : !cir.bool -> !s32i
+ // CHECK-NEXT: %{{.+}} = cir.cast integral %[[CAST2]] : !s32i -> !s64i
// CHECK-NEXT: cir.return %[[CAST]] : !cir.bool
cir.func @no_fold_cast(%arg0: !s32i) -> !s64i {
@@ -229,6 +243,7 @@ module {
cir.return %1 : !s64i
}
// CHECK: @cast_poison
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.poison : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.poison : !s64i
// CHECK-NEXT: cir.return %[[P]] : !s64i
// CHECK-NEXT: }
@@ -239,6 +254,7 @@ module {
cir.return %1 : !s64i
}
// CHECK: @cast_undef
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.undef : !s32i
// CHECK-NEXT: %[[U:.+]] = cir.const #cir.undef : !s64i
// CHECK-NEXT: cir.return %[[U]] : !s64i
@@ -248,6 +264,7 @@ module {
cir.return %1 : !s64i
}
// CHECK: @cast_s32_s64()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<2> : !s64i
// CHECK-NEXT: cir.return %[[P]] : !s64i
// CHECK-NEXT: }
@@ -258,6 +275,7 @@ module {
cir.return %1 : !s32i
}
// CHECK: @cast_s64_s32()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !s64i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: cir.return %[[P]] : !s32i
// CHECK-NEXT: }
@@ -268,6 +286,7 @@ module {
cir.return %1 : !u32i
}
// CHECK: @cast_s32_u32()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<2> : !u32i
// CHECK-NEXT: cir.return %[[P]] : !u32i
// CHECK-NEXT: }
@@ -278,6 +297,7 @@ module {
cir.return %1 : !s32i
}
// CHECK: @cast_u32_s32()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !u32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<2> : !s32i
// CHECK-NEXT: cir.return %[[P]] : !s32i
// CHECK-NEXT: }
@@ -288,6 +308,7 @@ module {
cir.return %1 : !s8i
}
// CHECK: @cast_overflow()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<259> : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<3> : !s8i
// CHECK-NEXT: cir.return %[[P]] : !s8i
// CHECK-NEXT: }
@@ -298,6 +319,7 @@ module {
cir.return %1 : !s64i
}
// CHECK: @cast_sext_s32_s64()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<-1> : !s64i
// CHECK-NEXT: cir.return %[[P]] : !s64i
// CHECK-NEXT: }
@@ -308,6 +330,7 @@ module {
cir.return %1 : !u64i
}
// CHECK: @cast_sext_s32_u64()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<-1> : !s32i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<18446744073709551615> : !u64i
// CHECK-NEXT: cir.return %[[P]] : !u64i
// CHECK-NEXT: }
@@ -320,6 +343,8 @@ module {
}
// CHECK: @cast_sext_twostep_s32_u64()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<-1> : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<-1> : !s64i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<18446744073709551615> : !u64i
// CHECK-NEXT: cir.return %[[P]] : !u64i
// CHECK-NEXT: }
@@ -330,6 +355,7 @@ module {
cir.return %1 : !u32i
}
// CHECK: @cast_zext_u8_u32()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<255> : !u8i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<255> : !u32i
// CHECK-NEXT: cir.return %[[P]] : !u32i
// CHECK-NEXT: }
@@ -340,6 +366,7 @@ module {
cir.return %1 : !s32i
}
// CHECK: @cast_zext_u8_s32()
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<255> : !u8i
// CHECK-NEXT: %[[P:.+]] = cir.const #cir.int<255> : !s32i
// CHECK-NEXT: cir.return %[[P]] : !s32i
// CHECK-NEXT: }
diff --git a/clang/test/CIR/Transforms/select.cir b/clang/test/CIR/Transforms/select.cir
index a2473b05457b38..d2f440924aae7c 100644
--- a/clang/test/CIR/Transforms/select.cir
+++ b/clang/test/CIR/Transforms/select.cir
@@ -11,6 +11,7 @@ module {
}
// CHECK: cir.func{{.*}} @fold_true(%[[ARG0:.+]]: !s32i, %[[ARG1:.+]]: !s32i) -> !s32i {
+ // CHECK-NEXT: %{{.+}} = cir.const #true
// CHECK-NEXT: cir.return %[[ARG0]] : !s32i
// CHECK-NEXT: }
@@ -21,6 +22,7 @@ module {
}
// CHECK: cir.func{{.*}} @fold_false(%[[ARG0:.+]]: !s32i, %[[ARG1:.+]]: !s32i) -> !s32i {
+ // CHECK-NEXT: %{{.+}} = cir.const #false
// CHECK-NEXT: cir.return %[[ARG1]] : !s32i
// CHECK-NEXT: }
@@ -43,6 +45,7 @@ module {
}
// CHECK: cir.func{{.*}} @fold_to_const(%{{.+}}: !cir.bool) -> !s32i {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<42> : !s32i
// CHECK-NEXT: %[[#A:]] = cir.const #cir.int<42> : !s32i
// CHECK-NEXT: cir.return %[[#A]] : !s32i
// CHECK-NEXT: }
diff --git a/clang/test/CIR/Transforms/vector-cmp-fold.cir b/clang/test/CIR/Transforms/vector-cmp-fold.cir
index 0d18af84ec145c..a4d4d444112e44 100644
--- a/clang/test/CIR/Transforms/vector-cmp-fold.cir
+++ b/clang/test/CIR/Transforms/vector-cmp-fold.cir
@@ -11,6 +11,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -29,6 +31,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i,
// CHECK-SAME: #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -47,6 +51,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i,
// CHECK-SAME: #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -65,6 +71,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i,
// CHECK-SAME: #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -83,6 +91,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -101,6 +111,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -121,6 +133,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -141,6 +155,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i,
// CHECK-SAME: #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -161,6 +177,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i,
// CHECK-SAME: #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -181,6 +199,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s32i, #cir.int<-1> : !s32i,
// CHECK-SAME: #cir.int<-1> : !s32i, #cir.int<-1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -201,6 +221,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -221,6 +243,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -244,6 +268,8 @@ module {
// 255>254 (T), 0>255 (F), 1>255 (F), 254>255 (F) -> [-1, 0, 0, 0]
// CHECK: cir.func{{.*}} @fold_cmp_vector_unsigned_gt() -> !cir.vector<4 x !s8i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<255> : !u8i, #cir.int<0> : !u8i, #cir.int<1> : !u8i, #cir.int<254> : !u8i]> : !cir.vector<4 x !u8i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<254> : !u8i, #cir.int<255> : !u8i, #cir.int<255> : !u8i, #cir.int<255> : !u8i]> : !cir.vector<4 x !u8i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s8i, #cir.int<0> : !s8i,
// CHECK-SAME: #cir.int<0> : !s8i, #cir.int<0> : !s8i]> : !cir.vector<4 x !s8i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s8i>
@@ -264,6 +290,8 @@ module {
// 0<255 (T), 255<0 (F), 128<129 (T), 127<128 (T) -> [-1, 0, -1, -1]
// CHECK: cir.func{{.*}} @fold_cmp_vector_unsigned_lt() -> !cir.vector<4 x !s8i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<0> : !u8i, #cir.int<255> : !u8i, #cir.int<128> : !u8i, #cir.int<127> : !u8i]> : !cir.vector<4 x !u8i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<255> : !u8i, #cir.int<0> : !u8i, #cir.int<129> : !u8i, #cir.int<128> : !u8i]> : !cir.vector<4 x !u8i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !s8i, #cir.int<0> : !s8i,
// CHECK-SAME: #cir.int<-1> : !s8i, #cir.int<-1> : !s8i]> : !cir.vector<4 x !s8i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s8i>
@@ -288,6 +316,8 @@ module {
// 1<2, 3<4, 5<6, 7<8 are all true -> [-1, -1, -1, -1]
// CHECK: cir.func{{.*}} @fold_cmp_vector_op_test_i1_result() -> !cir.vector<4 x !cir.int<s, 1>> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<-1> : !cir.int<s, 1>, #cir.int<-1> : !cir.int<s, 1>,
// CHECK-SAME: #cir.int<-1> : !cir.int<s, 1>, #cir.int<-1> : !cir.int<s, 1>]> : !cir.vector<4 x !cir.int<s, 1>>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !cir.int<s, 1>>
diff --git a/clang/test/CIR/Transforms/vector-create-fold.cir b/clang/test/CIR/Transforms/vector-create-fold.cir
index fb8c39e4dda402..d30117a5d800e7 100644
--- a/clang/test/CIR/Transforms/vector-create-fold.cir
+++ b/clang/test/CIR/Transforms/vector-create-fold.cir
@@ -13,6 +13,10 @@ module {
}
// CHECK: cir.func{{.*}} @fold_create_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<1> : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<2> : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<3> : !s32i
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.int<4> : !s32i
// CHECK-NEXT: %[[VEC:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i,
// CHECK-SAME: #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[VEC]] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/Transforms/vector-shuffle-dynamic-fold.cir b/clang/test/CIR/Transforms/vector-shuffle-dynamic-fold.cir
index 6584df3d7050bd..63cb68f588729f 100644
--- a/clang/test/CIR/Transforms/vector-shuffle-dynamic-fold.cir
+++ b/clang/test/CIR/Transforms/vector-shuffle-dynamic-fold.cir
@@ -12,6 +12,8 @@ module {
// Masking indices [8, 7, 6, 5] AND 3 = [0, 3, 2, 1]
// CHECK: cir.func{{.*}} @fold_shuffle_dynamic_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<8> : !s32i, #cir.int<7> : !s32i, #cir.int<6> : !s32i, #cir.int<5> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[NEW_VEC:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<4> : !s32i, #cir.int<3> : !s32i, #cir.int<2> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[NEW_VEC:.*]] : !cir.vector<4 x !s32i>
@@ -24,6 +26,8 @@ module {
// Masking indices [3, 2, 1, 0] AND 3 = [3, 2, 1, 0]
// CHECK: cir.func{{.*}} @fold_shuffle_dynamic_vector_op_test_2() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<3> : !s32i, #cir.int<2> : !s32i, #cir.int<1> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[NEW_VEC:.*]] = cir.const #cir.const_vector<[#cir.int<4> : !s32i, #cir.int<3> : !s32i, #cir.int<2> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[NEW_VEC:.*]] : !cir.vector<4 x !s32i>
}
diff --git a/clang/test/CIR/Transforms/vector-shuffle-fold.cir b/clang/test/CIR/Transforms/vector-shuffle-fold.cir
index 7aaddc051a75bc..afffcc9fe7cecd 100644
--- a/clang/test/CIR/Transforms/vector-shuffle-fold.cir
+++ b/clang/test/CIR/Transforms/vector-shuffle-fold.cir
@@ -13,6 +13,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_shuffle_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CHECK-SAME: #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
@@ -33,6 +35,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_shuffle_vector_op_test() -> !cir.vector<6 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CHECK-SAME: #cir.int<4> : !s32i, #cir.int<5> : !s32i, #cir.int<6> : !s32i]> : !cir.vector<6 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<6 x !s32i>
@@ -53,6 +57,8 @@ module {
}
// CHECK: cir.func{{.*}} @fold_shuffle_vector_op_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK: cir.const #cir.const_vector<[#cir.undef : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i,
// CHECK-SAME: #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
diff --git a/clang/test/CIR/Transforms/vector-ternary-fold.cir b/clang/test/CIR/Transforms/vector-ternary-fold.cir
index 3de614a39264fe..8c663e65d67a6c 100644
--- a/clang/test/CIR/Transforms/vector-ternary-fold.cir
+++ b/clang/test/CIR/Transforms/vector-ternary-fold.cir
@@ -13,6 +13,9 @@ module {
// [1, 0, 1, 0] ? [1, 2, 3, 4] : [5, 6, 7, 8] Will be fold to [1, 6, 3, 8]
// CHECK: cir.func{{.*}} @vector_ternary_fold_test() -> !cir.vector<4 x !s32i> {
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<0> : !s32i, #cir.int<1> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<2> : !s32i, #cir.int<3> : !s32i, #cir.int<4> : !s32i]> : !cir.vector<4 x !s32i>
+ // CHECK-NEXT: %{{.+}} = cir.const #cir.const_vector<[#cir.int<5> : !s32i, #cir.int<6> : !s32i, #cir.int<7> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<6> : !s32i, #cir.int<3> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
}
More information about the llvm-branch-commits
mailing list