https://github.com/AmrDeveloper created
https://github.com/llvm/llvm-project/pull/154107
Run Lowering preparing pass conditionally if the action is not to emit CIR
>From ecd8ca3f42042ef65eef73cb743847538cededd1 Mon Sep 17 00:00:00 2001
From: AmrDeveloper <am...@programmer.net>
Date: Mon, 18 Aug 2025 12:08:04 +0200
Subject: [PATCH] [CIR] Run LoweringPrepare pass only for non CIR output
---
clang/include/clang/CIR/CIRToCIRPasses.h | 13 +-
clang/lib/CIR/FrontendAction/CIRGenAction.cpp | 3 +-
clang/lib/CIR/Lowering/CIRPasses.cpp | 13 +-
clang/test/CIR/CodeGen/array-ctor.cpp | 46 +----
clang/test/CIR/CodeGen/array-dtor.cpp | 41 +----
clang/test/CIR/CodeGen/complex-builtins.cpp | 13 +-
clang/test/CIR/CodeGen/complex-cast.cpp | 133 +++-----------
.../CodeGen/complex-compound-assignment.cpp | 57 +-----
clang/test/CIR/CodeGen/complex-mul-div.cpp | 95 ++--------
clang/test/CIR/CodeGen/complex-unary.cpp | 170 +++++-------------
clang/test/CIR/CodeGen/complex.cpp | 3 +-
clang/test/CIR/CodeGen/destructors.cpp | 36 ++--
.../combined-private-clause.cpp | 58 ++----
.../CodeGenOpenACC/compute-private-clause.cpp | 58 ++----
.../CodeGenOpenACC/loop-private-clause.cpp | 58 ++----
15 files changed, 197 insertions(+), 600 deletions(-)
diff --git a/clang/include/clang/CIR/CIRToCIRPasses.h
b/clang/include/clang/CIR/CIRToCIRPasses.h
index 4a23790ee8b76..0229faaaf9fca 100644
--- a/clang/include/clang/CIR/CIRToCIRPasses.h
+++ b/clang/include/clang/CIR/CIRToCIRPasses.h
@@ -15,11 +15,9 @@
#include "mlir/Pass/Pass.h"
-#include <memory>
-
namespace clang {
class ASTContext;
-}
+} // namespace clang
namespace mlir {
class MLIRContext;
@@ -29,11 +27,10 @@ class ModuleOp;
namespace cir {
// Run set of cleanup/prepare/etc passes CIR <-> CIR.
-mlir::LogicalResult runCIRToCIRPasses(mlir::ModuleOp theModule,
- mlir::MLIRContext &mlirCtx,
- clang::ASTContext &astCtx,
- bool enableVerifier,
- bool enableCIRSimplify);
+mlir::LogicalResult
+runCIRToCIRPasses(mlir::ModuleOp theModule, mlir::MLIRContext &mlirCtx,
+ clang::ASTContext &astCtx, bool enableVerifier,
+ bool enableCIRSimplify, bool enableLoweringPrepare);
} // namespace cir
diff --git a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp
b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp
index 67bb5657d4001..0651910e83d57 100644
--- a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp
+++ b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp
@@ -110,9 +110,10 @@ class CIRGenConsumer : public clang::ASTConsumer {
if (!FEOptions.ClangIRDisablePasses) {
// Setup and run CIR pipeline.
+ bool EnableLoweringPrepare = Action != CIRGenAction::OutputType::EmitCIR;
if (runCIRToCIRPasses(MlirModule, MlirCtx, C,
!FEOptions.ClangIRDisableCIRVerifier,
- CGO.OptimizationLevel > 0)
+ CGO.OptimizationLevel > 0, EnableLoweringPrepare)
.failed()) {
CI.getDiagnostics().Report(diag::err_cir_to_cir_transform_failed);
return;
diff --git a/clang/lib/CIR/Lowering/CIRPasses.cpp
b/clang/lib/CIR/Lowering/CIRPasses.cpp
index bb9781be897eb..9acfaca9afbd2 100644
--- a/clang/lib/CIR/Lowering/CIRPasses.cpp
+++ b/clang/lib/CIR/Lowering/CIRPasses.cpp
@@ -10,18 +10,16 @@
//
//===----------------------------------------------------------------------===//
-// #include "clang/AST/ASTContext.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/PassManager.h"
#include "clang/CIR/Dialect/Passes.h"
#include "llvm/Support/TimeProfiler.h"
namespace cir {
-mlir::LogicalResult runCIRToCIRPasses(mlir::ModuleOp theModule,
- mlir::MLIRContext &mlirContext,
- clang::ASTContext &astContext,
- bool enableVerifier,
- bool enableCIRSimplify) {
+mlir::LogicalResult
+runCIRToCIRPasses(mlir::ModuleOp theModule, mlir::MLIRContext &mlirContext,
+ clang::ASTContext &astContext, bool enableVerifier,
+ bool enableCIRSimplify, bool enableLoweringPrepare) {
llvm::TimeTraceScope scope("CIR To CIR Passes");
@@ -31,7 +29,8 @@ mlir::LogicalResult runCIRToCIRPasses(mlir::ModuleOp
theModule,
if (enableCIRSimplify)
pm.addPass(mlir::createCIRSimplifyPass());
- pm.addPass(mlir::createLoweringPreparePass(&astContext));
+ if (enableLoweringPrepare)
+ pm.addPass(mlir::createLoweringPreparePass(&astContext));
pm.enableVerifier(enableVerifier);
(void)mlir::applyPassManagerCLOptions(pm);
diff --git a/clang/test/CIR/CodeGen/array-ctor.cpp
b/clang/test/CIR/CodeGen/array-ctor.cpp
index c373acf0bff8c..0a2762973b1b6 100644
--- a/clang/test/CIR/CodeGen/array-ctor.cpp
+++ b/clang/test/CIR/CodeGen/array-ctor.cpp
@@ -1,6 +1,5 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-cir -mmlir --mlir-print-ir-before=cir-lowering-prepare %s -o -
2>&1 | FileCheck --check-prefixes=CIR-BEFORE-LPP %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-cir %s -o %t.cir
-// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s --check-prefixes=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-emit-llvm %s -o %t.ll
@@ -14,35 +13,13 @@ void foo() {
S s[42];
}
-// CIR-BEFORE-LPP: cir.func dso_local @_Z3foov()
-// CIR-BEFORE-LPP: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 42>,
!cir.ptr<!cir.array<!rec_S x 42>>, ["s", init]
-// CIR-BEFORE-LPP: cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x
42>> {
-// CIR-BEFORE-LPP: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S>):
-// CIR-BEFORE-LPP: cir.call @_ZN1SC1Ev(%[[ARG]]) : (!cir.ptr<!rec_S>) ->
()
-// CIR-BEFORE-LPP: cir.yield
-// CIR-BEFORE-LPP: }
-// CIR-BEFORE-LPP: cir.return
-// CIR-BEFORE-LPP: }
-
// CIR: cir.func dso_local @_Z3foov()
// CIR: %[[ARRAY:.*]] = cir.alloca !cir.array<!rec_S x 42>,
!cir.ptr<!cir.array<!rec_S x 42>>, ["s", init]
-// CIR: %[[CONST42:.*]] = cir.const #cir.int<42> : !u64i
-// CIR: %[[DECAY:.*]] = cir.cast(array_to_ptrdecay, %[[ARRAY]] :
!cir.ptr<!cir.array<!rec_S x 42>>), !cir.ptr<!rec_S>
-// CIR: %[[END_PTR:.*]] = cir.ptr_stride(%[[DECAY]] : !cir.ptr<!rec_S>,
%[[CONST42]] : !u64i), !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>,
!cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
-// CIR: cir.store %[[DECAY]], %[[ITER]] : !cir.ptr<!rec_S>,
!cir.ptr<!cir.ptr<!rec_S>>
-// CIR: cir.do {
-// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>,
!cir.ptr<!rec_S>
-// CIR: cir.call @_ZN1SC1Ev(%[[CURRENT]]) : (!cir.ptr<!rec_S>) -> ()
-// CIR: %[[CONST1:.*]] = cir.const #cir.int<1> : !u64i
-// CIR: %[[NEXT:.*]] = cir.ptr_stride(%[[CURRENT]] : !cir.ptr<!rec_S>,
%[[CONST1]] : !u64i), !cir.ptr<!rec_S>
-// CIR: cir.store %[[NEXT]], %[[ITER]] : !cir.ptr<!rec_S>,
!cir.ptr<!cir.ptr<!rec_S>>
-// CIR: cir.yield
-// CIR: } while {
-// CIR: %[[CURRENT2:.*]] = cir.load %[[ITER]] :
!cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
-// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[CURRENT2]], %[[END_PTR]]) :
!cir.ptr<!rec_S>, !cir.bool
-// CIR: cir.condition(%[[CMP]])
-// CIR: }
+// CIR: cir.array.ctor %[[ARRAY]] : !cir.ptr<!cir.array<!rec_S x 42>> {
+// CIR: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_S> {{.*}}):
+// CIR: cir.call @_ZN1SC1Ev(%[[ARG]]) : (!cir.ptr<!rec_S>) -> ()
+// CIR: cir.yield
+// CIR: }
// CIR: cir.return
// CIR: }
@@ -84,15 +61,9 @@ void zero_sized() {
S s[0];
}
-// CIR-BEFORE-LPP: cir.func dso_local @_Z10zero_sizedv()
-// CIR-BEFORE-LPP: cir.alloca !cir.array<!rec_S x 0>,
!cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
-// CIR-BEFORE-LPP-NOT: cir.array.ctor
-// CIR-BEFORE-LPP: cir.return
-
// CIR: cir.func dso_local @_Z10zero_sizedv()
// CIR: cir.alloca !cir.array<!rec_S x 0>, !cir.ptr<!cir.array<!rec_S x
0>>, ["s"]
-// CIR-NOT: cir.do
-// CIR-NOT: cir.call @_ZN1SC1Ev
+// CIR-NOT: cir.array.ctor
// CIR: cir.return
// LLVM: define dso_local void @_Z10zero_sizedv()
@@ -104,3 +75,4 @@ void zero_sized() {
// OGCG: alloca [0 x %struct.S]
// OGCG-NOT: call void @_ZN1SC1Ev
// OGCG: ret void
+
diff --git a/clang/test/CIR/CodeGen/array-dtor.cpp
b/clang/test/CIR/CodeGen/array-dtor.cpp
index 3edc6f1a6538d..19b2ff1dfd3de 100644
--- a/clang/test/CIR/CodeGen/array-dtor.cpp
+++ b/clang/test/CIR/CodeGen/array-dtor.cpp
@@ -1,6 +1,5 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-cir -mmlir --mlir-print-ir-before=cir-lowering-prepare %s -o
%t.cir 2> %t-before-lp.cir
-// RUN: FileCheck --input-file=%t-before-lp.cir %s -check-prefix=CIR-BEFORE-LPP
-// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s --check-prefixes=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-emit-llvm %s -o %t.ll
@@ -14,33 +13,12 @@ void test_cleanup_array() {
S s[42];
}
-// CIR-BEFORE-LPP: cir.func{{.*}} @_Z18test_cleanup_arrayv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 42>,
!cir.ptr<!cir.array<!rec_S x 42>>, ["s"]
-// CIR-BEFORE-LPP: cir.array.dtor %[[S]] : !cir.ptr<!cir.array<!rec_S x 42>>
{
-// CIR-BEFORE-LPP: ^bb0(%arg0: !cir.ptr<!rec_S>
-// CIR-BEFORE-LPP: cir.call @_ZN1SD1Ev(%arg0) nothrow : (!cir.ptr<!rec_S>)
-> ()
-// CIR-BEFORE-LPP: cir.yield
-// CIR-BEFORE-LPP: }
-// CIR-BEFORE-LPP: cir.return
-
// CIR: cir.func{{.*}} @_Z18test_cleanup_arrayv()
// CIR: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 42>,
!cir.ptr<!cir.array<!rec_S x 42>>, ["s"]
-// CIR: %[[CONST41:.*]] = cir.const #cir.int<41> : !u64i
-// CIR: %[[DECAY:.*]] = cir.cast(array_to_ptrdecay, %[[S]] :
!cir.ptr<!cir.array<!rec_S x 42>>), !cir.ptr<!rec_S>
-// CIR: %[[END_PTR:.*]] = cir.ptr_stride(%[[DECAY]] : !cir.ptr<!rec_S>,
%[[CONST41]] : !u64i), !cir.ptr<!rec_S>
-// CIR: %[[ITER:.*]] = cir.alloca !cir.ptr<!rec_S>,
!cir.ptr<!cir.ptr<!rec_S>>, ["__array_idx"]
-// CIR: cir.store %[[END_PTR]], %[[ITER]] : !cir.ptr<!rec_S>,
!cir.ptr<!cir.ptr<!rec_S>>
-// CIR: cir.do {
-// CIR: %[[CURRENT:.*]] = cir.load %[[ITER]] : !cir.ptr<!cir.ptr<!rec_S>>,
!cir.ptr<!rec_S>
-// CIR: cir.call @_ZN1SD1Ev(%[[CURRENT]]) nothrow : (!cir.ptr<!rec_S>) ->
()
-// CIR: %[[CONST_MINUS1:.*]] = cir.const #cir.int<-1> : !s64i
-// CIR: %[[NEXT:.*]] = cir.ptr_stride(%[[CURRENT]] : !cir.ptr<!rec_S>,
%[[CONST_MINUS1]] : !s64i), !cir.ptr<!rec_S>
-// CIR: cir.store %[[NEXT]], %[[ITER]] : !cir.ptr<!rec_S>,
!cir.ptr<!cir.ptr<!rec_S>>
+// CIR: cir.array.dtor %[[S]] : !cir.ptr<!cir.array<!rec_S x 42>> {
+// CIR: ^bb0(%arg0: !cir.ptr<!rec_S>
+// CIR: cir.call @_ZN1SD1Ev(%arg0) nothrow : (!cir.ptr<!rec_S>) -> ()
// CIR: cir.yield
-// CIR: } while {
-// CIR: %[[CURRENT2:.*]] = cir.load %[[ITER]] :
!cir.ptr<!cir.ptr<!rec_S>>, !cir.ptr<!rec_S>
-// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[CURRENT2]], %[[DECAY]])
-// CIR: cir.condition(%[[CMP]])
// CIR: }
// CIR: cir.return
@@ -82,15 +60,9 @@ void test_cleanup_zero_length_array() {
S s[0];
}
-// CIR-BEFORE-LPP: cir.func{{.*}} @_Z30test_cleanup_zero_length_arrayv()
-// CIR-BEFORE-LPP: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 0>,
!cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
-// CIR-BEFORE-LPP-NOT: cir.array.dtor
-// CIR-BEFORE-LPP: cir.return
-
// CIR: cir.func{{.*}} @_Z30test_cleanup_zero_length_arrayv()
// CIR: %[[S:.*]] = cir.alloca !cir.array<!rec_S x 0>,
!cir.ptr<!cir.array<!rec_S x 0>>, ["s"]
-// CIR-NOT: cir.do
-// CIR-NOT: cir.call @_ZN1SD1Ev
+// CIR-NOT: cir.array.dtor
// CIR: cir.return
// LLVM: define{{.*}} void @_Z30test_cleanup_zero_length_arrayv()
@@ -102,3 +74,4 @@ void test_cleanup_zero_length_array() {
// OGCG: alloca [0 x %struct.S]
// OGCG-NOT: call void @_ZN1SD1Ev
// OGCG: ret void
+
diff --git a/clang/test/CIR/CodeGen/complex-builtins.cpp
b/clang/test/CIR/CodeGen/complex-builtins.cpp
index 811af47a704f5..1f3c31079c1f9 100644
--- a/clang/test/CIR/CodeGen/complex-builtins.cpp
+++ b/clang/test/CIR/CodeGen/complex-builtins.cpp
@@ -89,14 +89,11 @@ void foo4() {
float _Complex b = __builtin_conjf(a);
}
-// CIR: %[[COMPLEX:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR: %[[RESULT:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[COMPLEX]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!cir.float> ->
!cir.float
-// CIR: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!cir.float> ->
!cir.float
-// CIR: %[[IMAG_MINUS:.*]] = cir.unary(minus, %[[IMAG]]) : !cir.float,
!cir.float
-// CIR: %[[RESULT_VAL:.*]] = cir.complex.create %[[REAL]], %[[IMAG_MINUS]] :
!cir.float -> !cir.complex<!cir.float>
-// CIR: cir.store{{.*}} %[[RESULT_VAL]], %[[RESULT]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[RESULT:.*]] = cir.unary(not, %[[TMP_A]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[RESULT]], %[[B_ADDR]] : !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[COMPLEX:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[RESULT:.*]] = alloca { float, float }, i64 1, align 4
diff --git a/clang/test/CIR/CodeGen/complex-cast.cpp
b/clang/test/CIR/CodeGen/complex-cast.cpp
index a8f51cd627f9d..c6bfa89443687 100644
--- a/clang/test/CIR/CodeGen/complex-cast.cpp
+++ b/clang/test/CIR/CodeGen/complex-cast.cpp
@@ -1,5 +1,5 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir
--mlir-print-ir-before=cir-canonicalize -o %t.cir %s 2>&1 | FileCheck
--check-prefix=CIR-BEFORE %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir
--mlir-print-ir-after=cir-lowering-prepare -o %t.cir %s 2>&1 | FileCheck
--check-prefixes=CIR-AFTER %s
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s --check-prefixes=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-emit-llvm %s -o %t.ll
@@ -20,11 +20,7 @@ void scalar_to_complex() {
ci = sd;
}
-// CIR-BEFORE: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex, %{{.*}} :
!cir.double), !cir.complex<!cir.double>
-
-// CIR-AFTER: %[[REAL:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.double>, !cir.double
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.double
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] :
!cir.double -> !cir.complex<!cir.double>
+// CIR: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex, %{{.*}} :
!cir.double), !cir.complex<!cir.double>
// LLVM: %[[REAL:.*]] = load double, ptr {{.*}}, align 8
// LLVM-NEXT: %[[TMP:.*]] = insertvalue { double, double } undef, double
%[[REAL]], 0
@@ -35,11 +31,7 @@ void scalar_to_complex() {
// OGCG: store double %[[REAL]], ptr {{.*}}, align 8
// OGCG: store double 0.000000e+00, ptr getelementptr inbounds nuw ({ double,
double }, ptr @cd, i32 0, i32 1), align 8
-// CIR-BEFORE: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex, %{{.*}} :
!s32i), !cir.complex<!s32i>
-
-// CIR-AFTER: %[[REAL:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!s32i>,
!s32i
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.int<0> : !s32i
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] : !s32i
-> !cir.complex<!s32i>
+// CIR: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex, %{{.*}} : !s32i),
!cir.complex<!s32i>
// LLVM: %[[REAL:.*]] = load i32, ptr {{.*}}, align 4
// LLVM-NEXT: %[[TMP:.*]] = insertvalue { i32, i32 } undef, i32 %[[REAL]], 0
@@ -50,13 +42,8 @@ void scalar_to_complex() {
// OGCG: store i32 %[[REAL]], ptr {{.*}}, align 4
// OGCG: store i32 0, ptr getelementptr inbounds nuw ({ i32, i32 }, ptr @ci,
i32 0, i32 1), align 4
-// CIR-BEFORE: %[[INT_TO_FP:.*]] = cir.cast(int_to_float, %{{.*}} : !s32i),
!cir.double
-// CIR-BEFORE: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex,
%[[INT_TO_FP]] : !cir.double), !cir.complex<!cir.double>
-
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!s32i>,
!s32i
-// CIR-AFTER-NEXT: %[[REAL:.*]] = cir.cast(int_to_float, %[[TMP]] : !s32i),
!cir.double
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.double
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] :
!cir.double -> !cir.complex<!cir.double>
+// CIR: %[[INT_TO_FP:.*]] = cir.cast(int_to_float, %{{.*}} : !s32i),
!cir.double
+// CIR: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex, %[[INT_TO_FP]] :
!cir.double), !cir.complex<!cir.double>
// LLVM: %[[TMP:.*]] = load i32, ptr {{.*}}, align 4
// LLVM-NEXT: %[[REAL:.*]] = sitofp i32 %[[TMP]] to double
@@ -69,13 +56,8 @@ void scalar_to_complex() {
// OGCG: store double %[[REAL]], ptr {{.*}}, align 8
// OGCG: store double 0.000000e+00, ptr getelementptr inbounds nuw ({ double,
double }, ptr {{.*}}, i32 0, i32 1), align 8
-// CIR-BEFORE: %[[FP_TO_INT:.*]] = cir.cast(float_to_int, %{{.*}} :
!cir.double), !s32i
-// CIR-BEFORE: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex,
%[[FP_TO_INT]] : !s32i), !cir.complex<!s32i>
-
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.double>, !cir.double
-// CIR-AFTER-NEXT: %[[REAL:.*]] = cir.cast(float_to_int, %[[TMP]] :
!cir.double), !s32i
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.int<0> : !s32i
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] : !s32i
-> !cir.complex<!s32i>
+// CIR: %[[FP_TO_INT:.*]] = cir.cast(float_to_int, %{{.*}} : !cir.double),
!s32i
+// CIR: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex, %[[FP_TO_INT]] :
!s32i), !cir.complex<!s32i>
// LLVM: %[[TMP:.*]] = load double, ptr {{.*}}, align 8
// LLVM-NEXT: %[[REAL:.*]] = fptosi double %[[TMP]] to i32
@@ -95,11 +77,7 @@ void scalar_to_complex_explicit() {
ci = (int _Complex)sd;
}
-// CIR-BEFORE: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex, %{{.*}} :
!cir.double), !cir.complex<!cir.double>
-
-// CIR-AFTER: %[[REAL:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.double>, !cir.double
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.double
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] :
!cir.double -> !cir.complex<!cir.double>
+// CIR: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex, %{{.*}} :
!cir.double), !cir.complex<!cir.double>
// LLVM: %[[REAL:.*]] = load double, ptr {{.*}}, align 8
// LLVM-NEXT: %[[TMP:.*]] = insertvalue { double, double } undef, double
%[[REAL]], 0
@@ -110,11 +88,7 @@ void scalar_to_complex_explicit() {
// OGCG: store double %[[REAL]], ptr {{.*}}, align 8
// OGCG: store double 0.000000e+00, ptr getelementptr inbounds nuw ({ double,
double }, ptr @cd, i32 0, i32 1), align 8
-// CIR-BEFORE: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex, %{{.*}} :
!s32i), !cir.complex<!s32i>
-
-// CIR-AFTER: %[[REAL:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!s32i>,
!s32i
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.int<0> : !s32i
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] : !s32i
-> !cir.complex<!s32i>
+// CIR: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex, %{{.*}} : !s32i),
!cir.complex<!s32i>
// LLVM: %[[REAL:.*]] = load i32, ptr {{.*}}, align 4
// LLVM-NEXT: %[[TMP:.*]] = insertvalue { i32, i32 } undef, i32 %[[REAL]], 0
@@ -125,13 +99,8 @@ void scalar_to_complex_explicit() {
// OGCG: store i32 %[[REAL]], ptr {{.*}}, align 4
// OGCG: store i32 0, ptr getelementptr inbounds nuw ({ i32, i32 }, ptr @ci,
i32 0, i32 1), align 4
-// CIR-BEFORE: %[[INT_TO_FP:.*]] = cir.cast(int_to_float, %{{.*}} : !s32i),
!cir.double
-// CIR-BEFORE: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex,
%[[INT_TO_FP]] : !cir.double), !cir.complex<!cir.double>
-
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!s32i>,
!s32i
-// CIR-AFTER-NEXT: %[[REAL:.*]] = cir.cast(int_to_float, %[[TMP]] : !s32i),
!cir.double
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.double
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] :
!cir.double -> !cir.complex<!cir.double>
+// CIR: %[[INT_TO_FP:.*]] = cir.cast(int_to_float, %{{.*}} : !s32i),
!cir.double
+// CIR: %[[FP_TO_COMPLEX:.*]] = cir.cast(float_to_complex, %[[INT_TO_FP]] :
!cir.double), !cir.complex<!cir.double>
// LLVM: %[[TMP:.*]] = load i32, ptr {{.*}}, align 4
// LLVM-NEXT: %[[REAL:.*]] = sitofp i32 %[[TMP]] to double
@@ -144,13 +113,8 @@ void scalar_to_complex_explicit() {
// OGCG: store double %[[REAL]], ptr {{.*}}, align 8
// OGCG: store double 0.000000e+00, ptr getelementptr inbounds nuw ({ double,
double }, ptr {{.*}}, i32 0, i32 1), align 8
-// CIR-BEFORE: %[[FP_TO_INT:.*]] = cir.cast(float_to_int, %{{.*}} :
!cir.double), !s32i
-// CIR-BEFORE: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex,
%[[FP_TO_INT]] : !s32i), !cir.complex<!s32i>
-
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.double>, !cir.double
-// CIR-AFTER-NEXT: %[[REAL:.*]] = cir.cast(float_to_int, %[[TMP]] :
!cir.double), !s32i
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.const #cir.int<0> : !s32i
-// CIR-AFTER-NEXT: %{{.*}} = cir.complex.create %[[REAL]], %[[IMAG]] : !s32i
-> !cir.complex<!s32i>
+// CIR: %[[FP_TO_INT:.*]] = cir.cast(float_to_int, %{{.*}} : !cir.double),
!s32i
+// CIR: %[[INT_TO_COMPLEX:.*]] = cir.cast(int_to_complex, %[[FP_TO_INT]] :
!s32i), !cir.complex<!s32i>
// LLVM: %[[TMP:.*]] = load double, ptr {{.*}}, align 8
// LLVM-NEXT: %[[REAL:.*]] = fptosi double %[[TMP]] to i32
@@ -170,9 +134,7 @@ void complex_to_scalar() {
si = (int)cd;
}
-// CIR-BEFORE: %[[FP_TO_COMPLEX_REAL:.*]] = cir.cast(float_complex_to_real,
%{{.*}} : !cir.complex<!cir.double>), !cir.double
-
-// CIR-AFTER: %{{.*}} = cir.complex.real %{{.*}} : !cir.complex<!cir.double>
-> !cir.double
+// CIR: %[[FP_TO_COMPLEX_REAL:.*]] = cir.cast(float_complex_to_real, %{{.*}} :
!cir.complex<!cir.double>), !cir.double
// LLVM: %[[REAL:.*]] = extractvalue { double, double } %{{.*}}, 0
// LLVM: store double %[[REAL]], ptr {{.*}}, align 8
@@ -180,9 +142,7 @@ void complex_to_scalar() {
// OGCG: %[[REAL:.*]] = load double, ptr {{.*}}, align 8
// OGCG: store double %[[REAL]], ptr {{.*}}, align 8
-// CIR-BEFORE: %[[INT_COMPLEX_TO_REAL:.*]] = cir.cast(int_complex_to_real,
%{{.*}} : !cir.complex<!s32i>), !s32i
-
-// CIR-AFTER: %{{.*}} = cir.complex.real %{{.*}} : !cir.complex<!s32i> -> !s32i
+// CIR: %[[INT_COMPLEX_TO_REAL:.*]] = cir.cast(int_complex_to_real, %{{.*}} :
!cir.complex<!s32i>), !s32i
// LLVM: %[[REAL:.*]] = extractvalue { i32, i32 } %{{.*}}, 0
// LLVM: store i32 %[[REAL]], ptr {{.*}}, align 4
@@ -190,11 +150,8 @@ void complex_to_scalar() {
// OGCG: %[[REAL:.*]] = load i32, ptr {{.*}}, align 4
// OGCG: store i32 %[[REAL]], ptr {{.*}}, align 4
-// CIR-BEFORE: %[[INT_COMPLEX_TO_REAL:.*]] = cir.cast(int_complex_to_real,
%{{.*}} : !cir.complex<!s32i>), !s32i
-// CIR-BEFORE: %[[INT_TO_FP:.*]] = cir.cast(int_to_float,
%[[INT_COMPLEX_TO_REAL]] : !s32i), !cir.double
-
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %{{.*}} :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-NEXT: %{{.*}} = cir.cast(int_to_float, %[[REAL]] : !s32i),
!cir.double
+// CIR: %[[INT_COMPLEX_TO_REAL:.*]] = cir.cast(int_complex_to_real, %{{.*}} :
!cir.complex<!s32i>), !s32i
+// CIR: %[[INT_TO_FP:.*]] = cir.cast(int_to_float, %[[INT_COMPLEX_TO_REAL]] :
!s32i), !cir.double
// LLVM: %[[REAL:.*]] = extractvalue { i32, i32 } %{{.+}}, 0
// LLVM-NEXT: %[[REAL_TO_DOUBLE:.*]] = sitofp i32 %[[REAL]] to double
@@ -204,11 +161,8 @@ void complex_to_scalar() {
// OGCG: %[[INT_TO_FP:.*]] = sitofp i32 %[[REAL]] to double
// OGCG: store double %[[INT_TO_FP]], ptr {{.*}}, align 8
-// CIR-BEFORE: %[[FP_TO_COMPLEX_REAL:.*]] = cir.cast(float_complex_to_real,
%{{.*}} : !cir.complex<!cir.double>), !cir.double
-// CIR-BEFORE: %[[FP_TO_INT:.*]] = cir.cast(float_to_int,
%[[FP_TO_COMPLEX_REAL]] : !cir.double), !s32i
-
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %{{.*}} :
!cir.complex<!cir.double> -> !cir.double
-// CIR-AFTER-NEXT: %{{.*}} = cir.cast(float_to_int, %[[REAL]] : !cir.double),
!s32i
+// CIR: %[[FP_TO_COMPLEX_REAL:.*]] = cir.cast(float_complex_to_real, %{{.*}} :
!cir.complex<!cir.double>), !cir.double
+// CIR: %[[FP_TO_INT:.*]] = cir.cast(float_to_int, %[[FP_TO_COMPLEX_REAL]] :
!cir.double), !s32i
// LLVM: %[[REAL:.*]] = extractvalue { double, double } %{{.+}}, 0
// LLVM-NEXT: %[[REAL_TO_INT:.*]] = fptosi double %[[REAL]] to i32
@@ -223,14 +177,7 @@ void complex_to_bool() {
b = (bool)ci;
}
-// CIR-BEFORE: %[[FP_COMPLEX_TO_BOOL:.*]] = cir.cast(float_complex_to_bool,
%{{.*}} : !cir.complex<!cir.double>), !cir.bool
-
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %{{.*}} :
!cir.complex<!cir.double> -> !cir.double
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.complex.imag %{{.*}} :
!cir.complex<!cir.double> -> !cir.double
-// CIR-AFTER-NEXT: %[[REAL_TO_BOOL:.*]] = cir.cast(float_to_bool, %[[REAL]] :
!cir.double), !cir.bool
-// CIR-AFTER-NEXT: %[[IMAG_TO_BOOL:.*]] = cir.cast(float_to_bool, %[[IMAG]] :
!cir.double), !cir.bool
-// CIR-AFTER-NEXT: %[[CONST_TRUE:.*]] = cir.const #true
-// CIR-AFTER-NEXT: %{{.*}} = cir.select if %[[REAL_TO_BOOL]] then
%[[CONST_TRUE]] else %[[IMAG_TO_BOOL]] : (!cir.bool, !cir.bool, !cir.bool) ->
!cir.bool
+// CIR: %[[FP_COMPLEX_TO_BOOL:.*]] = cir.cast(float_complex_to_bool, %{{.*}} :
!cir.complex<!cir.double>), !cir.bool
// LLVM: %[[REAL:.*]] = extractvalue { double, double } %{{.*}}, 0
// LLVM-NEXT: %[[IMAG:.*]] = extractvalue { double, double } %{{.*}}, 1
@@ -248,14 +195,7 @@ void complex_to_bool() {
// OGCG: %[[BOOL_TO_INT:.*]] = zext i1 %[[COMPLEX_TO_BOOL]] to i8
// OGCG: store i8 %[[BOOL_TO_INT]], ptr {{.*}}, align 1
-// CIR-BEFORE: %[[INT_COMPLEX_TO_BOOL:.*]] = cir.cast(int_complex_to_bool,
%{{.*}} : !cir.complex<!s32i>), !cir.bool
-
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %{{.*}} :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-NEXT: %[[IMAG:.*]] = cir.complex.imag %{{.*}} :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-NEXT: %[[REAL_TO_BOOL:.*]] = cir.cast(int_to_bool, %[[REAL]] :
!s32i), !cir.bool
-// CIR-AFTER-NEXT: %[[IMAG_TO_BOOL:.*]] = cir.cast(int_to_bool, %[[IMAG]] :
!s32i), !cir.bool
-// CIR-AFTER-NEXT: %[[CONST_TRUE:.*]] = cir.const #true
-// CIR-AFTER-NEXT: %{{.+}} = cir.select if %[[REAL_TO_BOOL]] then
%[[CONST_TRUE]] else %[[IMAG_TO_BOOL]] : (!cir.bool, !cir.bool, !cir.bool) ->
!cir.bool
+// CIR: %[[INT_COMPLEX_TO_BOOL:.*]] = cir.cast(int_complex_to_bool, %{{.*}} :
!cir.complex<!s32i>), !cir.bool
// LLVM: %[[REAL:.*]] = extractvalue { i32, i32 } %{{.*}}, 0
// LLVM-NEXT: %[[IMAG:.*]] = extractvalue { i32, i32 } %{{.*}}, 1
@@ -278,14 +218,8 @@ void complex_to_complex_cast() {
ci = cs;
}
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[FP_COMPLEX:.*]] = cir.cast(float_complex, %[[TMP]] :
!cir.complex<!cir.float>), !cir.complex<!cir.double>
-
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %{{.*}} :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %{{.*}} :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_FP_CAST:.*]] = cir.cast(floating, %[[REAL]] :
!cir.float), !cir.double
-// CIR-AFTER: %[[IMAG_FP_CAST:.*]] = cir.cast(floating, %[[IMAG]] :
!cir.float), !cir.double
-// CIR-AFTER: %{{.*}} = cir.complex.create %[[REAL_FP_CAST]],
%[[IMAG_FP_CAST]] : !cir.double -> !cir.complex<!cir.double>
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[FP_COMPLEX:.*]] = cir.cast(float_complex, %[[TMP]] :
!cir.complex<!cir.float>), !cir.complex<!cir.double>
// LLVM: %[[REAL:.*]] = extractvalue { float, float } %{{.*}}, 0
// LLVM: %[[IMAG:.*]] = extractvalue { float, float } %{{.*}}, 1
@@ -302,14 +236,8 @@ void complex_to_complex_cast() {
// OGCG: store double %[[REAL_FP_CAST]], ptr {{.*}}, align 8
// OGCG: store double %[[IMAG_FP_CAST]], ptr getelementptr inbounds nuw ({
double, double }, ptr {{.*}}, i32 0, i32 1), align 8
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} :
!cir.ptr<!cir.complex<!s16i>>, !cir.complex<!s16i>
-// CIR-BEFORE: %[[INT_COMPLEX:.*]] = cir.cast(int_complex, %[[TMP]] :
!cir.complex<!s16i>), !cir.complex<!s32i>
-
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %{{.*}} : !cir.complex<!s16i> ->
!s16i
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %{{.*}} : !cir.complex<!s16i> ->
!s16i
-// CIR-AFTER: %[[REAL_INT_CAST:.*]] = cir.cast(integral, %[[REAL]] : !s16i),
!s32i
-// CIR-AFTER: %[[IMAG_INT_CAST:.*]] = cir.cast(integral, %[[IMAG]] : !s16i),
!s32i
-// CIR-AFTER: %{{.*}} = cir.complex.create %[[REAL_INT_CAST]],
%[[IMAG_INT_CAST]] : !s32i -> !cir.complex<!s32i>
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %{{.*}} : !cir.ptr<!cir.complex<!s16i>>,
!cir.complex<!s16i>
+// CIR: %[[INT_COMPLEX:.*]] = cir.cast(int_complex, %[[TMP]] :
!cir.complex<!s16i>), !cir.complex<!s32i>
// LLVM: %[[REAL:.*]] = extractvalue { i16, i16 } %{{.*}}, 0
// LLVM: %[[IMAG:.*]] = extractvalue { i16, i16 } %{{.*}}, 1
@@ -336,9 +264,7 @@ void lvalue_to_rvalue_bitcast() {
double _Complex b = __builtin_bit_cast(double _Complex, a);
}
-// CIR-BEFORE: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>),
!cir.ptr<!cir.complex<!cir.double>>
-
-// CIR-AFTER: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>),
!cir.ptr<!cir.complex<!cir.double>>
+// CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>),
!cir.ptr<!cir.complex<!cir.double>>
// LLVM: %[[PTR_ADDR:.*]] = alloca %struct.CX, i64 1, align 8
// LLVM: %[[COMPLEX_ADDR:.*]] = alloca { double, double }, i64 1, align 8
@@ -361,9 +287,7 @@ void lvalue_bitcast() {
(double _Complex &)a = {};
}
-// CIR-BEFORE: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>),
!cir.ptr<!cir.complex<!cir.double>>
-
-// CIR-AFTER: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>),
!cir.ptr<!cir.complex<!cir.double>>
+// CIR: %{{.*}} = cir.cast(bitcast, %{{.*}} : !cir.ptr<!rec_CX>),
!cir.ptr<!cir.complex<!cir.double>>
// LLVM: %[[A_ADDR:.*]] = alloca %struct.CX, i64 1, align 8
// LLVM: store { double, double } zeroinitializer, ptr %[[A_ADDR]], align 8
@@ -373,3 +297,4 @@ void lvalue_bitcast() {
// OGCG: %[[A_IMAG_PTR:.*]] = getelementptr inbounds nuw { double, double },
ptr %[[A_ADDR]], i32 0, i32 1
// OGCG: store double 0.000000e+00, ptr %[[A_REAL_PTR]], align 8
// OGCG: store double 0.000000e+00, ptr %[[A_IMAG_PTR]], align 8
+
diff --git a/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
b/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
index 9a6659bd5d93e..f53bee54b03bd 100644
--- a/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
+++ b/clang/test/CIR/CodeGen/complex-compound-assignment.cpp
@@ -149,27 +149,16 @@ void foo3() {
b += a;
}
+
// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>,
!cir.ptr<!cir.complex<!cir.f16>>, ["a"]
// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.f16>,
!cir.ptr<!cir.complex<!cir.f16>>, ["b"]
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
-// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!cir.f16>
-> !cir.f16
-// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!cir.f16>
-> !cir.f16
-// CIR: %[[A_REAL_F32:.*]] = cir.cast(floating, %[[A_REAL]] : !cir.f16),
!cir.float
-// CIR: %[[A_IMAG_F32:.*]] = cir.cast(floating, %[[A_IMAG]] : !cir.f16),
!cir.float
-// CIR: %[[A_COMPLEX_F32:.*]] = cir.complex.create %[[A_REAL_F32]],
%[[A_IMAG_F32]] : !cir.float -> !cir.complex<!cir.float>
+// CIR: %[[TMP_A_F32:.*]] = cir.cast(float_complex, %[[TMP_A]] :
!cir.complex<!cir.f16>), !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] :
!cir.ptr<!cir.complex<!cir.f16>>, !cir.complex<!cir.f16>
-// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!cir.f16>
-> !cir.f16
-// CIR: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] : !cir.complex<!cir.f16>
-> !cir.f16
-// CIR: %[[B_REAL_F32:.*]] = cir.cast(floating, %[[B_REAL]] : !cir.f16),
!cir.float
-// CIR: %[[B_IMAG_F32:.*]] = cir.cast(floating, %[[B_IMAG]] : !cir.f16),
!cir.float
-// CIR: %[[B_COMPLEX_F32:.*]] = cir.complex.create %[[B_REAL_F32]],
%[[B_IMAG_F32]] : !cir.float -> !cir.complex<!cir.float>
-// CIR: %[[ADD_A_B:.*]] = cir.complex.add %[[B_COMPLEX_F32]],
%[[A_COMPLEX_F32]] : !cir.complex<!cir.float>
-// CIR: %[[ADD_REAL:.*]] = cir.complex.real %[[ADD_A_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR: %[[ADD_IMAG:.*]] = cir.complex.imag %[[ADD_A_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR: %[[ADD_REAL_F16:.*]] = cir.cast(floating, %[[ADD_REAL]] : !cir.float),
!cir.f16
-// CIR: %[[ADD_IMAG_F16:.*]] = cir.cast(floating, %[[ADD_IMAG]] : !cir.float),
!cir.f16
-// CIR: %[[RESULT:.*]] = cir.complex.create %[[ADD_REAL_F16]],
%[[ADD_IMAG_F16]] : !cir.f16 -> !cir.complex<!cir.f16>
-// CIR: cir.store{{.*}} %[[RESULT]], %[[B_ADDR]] : !cir.complex<!cir.f16>,
!cir.ptr<!cir.complex<!cir.f16>>
+// CIR: %[[TMP_B_F32:.*]] = cir.cast(float_complex, %[[TMP_B]] :
!cir.complex<!cir.f16>), !cir.complex<!cir.float>
+// CIR: %[[RESULT_CF32:.*]] = cir.complex.add %[[TMP_B_F32]], %[[TMP_A_F32]] :
!cir.complex<!cir.float>
+// CIR: %[[RESULT_F16:.*]] = cir.cast(float_complex, %[[RESULT_CF32]] :
!cir.complex<!cir.float>), !cir.complex<!cir.f16>
+// CIR: cir.store{{.*}} %[[RESULT_F16]], %[[B_ADDR]] : !cir.complex<!cir.f16>,
!cir.ptr<!cir.complex<!cir.f16>>
// LLVM: %[[A_ADDR:.*]] = alloca { half, half }, i64 1, align 2
// LLVM: %[[B_ADDR:.*]] = alloca { half, half }, i64 1, align 2
@@ -337,17 +326,7 @@ void foo6() {
// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["b"]
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
-// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] : !cir.complex<!s32i> ->
!s32i
-// CIR: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] : !cir.complex<!s32i> ->
!s32i
-// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.complex<!s32i> ->
!s32i
-// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.complex<!s32i> ->
!s32i
-// CIR: %[[MUL_BR_AR:.*]] = cir.binop(mul, %[[B_REAL]], %[[A_REAL]]) : !s32i
-// CIR: %[[MUL_BI_AI:.*]] = cir.binop(mul, %[[B_IMAG]], %[[A_IMAG]]) : !s32i
-// CIR: %[[MUL_BR_AI:.*]] = cir.binop(mul, %[[B_REAL]], %[[A_IMAG]]) : !s32i
-// CIR: %[[MUL_BI_AR:.*]] = cir.binop(mul, %[[B_IMAG]], %[[A_REAL]]) : !s32i
-// CIR: %[[RESULT_REAL:.*]] = cir.binop(sub, %[[MUL_BR_AR]], %[[MUL_BI_AI]]) :
!s32i
-// CIR: %[[RESULT_IMAG:.*]] = cir.binop(add, %[[MUL_BR_AI]], %[[MUL_BI_AR]]) :
!s32i
-// CIR: %[[RESULT:.*]] = cir.complex.create %[[RESULT_REAL]], %[[RESULT_IMAG]]
: !s32i -> !cir.complex<!s32i>
+// CIR: %[[RESULT:.*]] = cir.complex.mul %[[TMP_B]], %[[TMP_A]] range(full) :
!cir.complex<!s32i>
// CIR: cir.store{{.*}} %[[RESULT]], %[[B_ADDR]] : !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>
// LLVM: %[[A_ADDR:.*]] = alloca { i32, i32 }, i64 1, align 4
@@ -399,27 +378,7 @@ void foo7() {
// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b"]
// CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
// CIR: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR: %[[MUL_BR_AR:.*]] = cir.binop(mul, %[[B_REAL]], %[[A_REAL]]) :
!cir.float
-// CIR: %[[MUL_BI_AI:.*]] = cir.binop(mul, %[[B_IMAG]], %[[A_IMAG]]) :
!cir.float
-// CIR: %[[MUL_BR_AI:.*]] = cir.binop(mul, %[[B_REAL]], %[[A_IMAG]]) :
!cir.float
-// CIR: %[[MUL_BI_AR:.*]] = cir.binop(mul, %[[B_IMAG]], %[[A_REAL]]) :
!cir.float
-// CIR: %[[C_REAL:.*]] = cir.binop(sub, %[[MUL_BR_AR]], %[[MUL_BI_AI]]) :
!cir.float
-// CIR: %[[C_IMAG:.*]] = cir.binop(add, %[[MUL_BR_AI]], %[[MUL_BI_AR]]) :
!cir.float
-// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[C_REAL]], %[[C_IMAG]] :
!cir.float -> !cir.complex<!cir.float>
-// CIR: %[[IS_C_REAL_NAN:.*]] = cir.cmp(ne, %[[C_REAL]], %[[C_REAL]]) :
!cir.float, !cir.bool
-// CIR: %[[IS_C_IMAG_NAN:.*]] = cir.cmp(ne, %[[C_IMAG]], %[[C_IMAG]]) :
!cir.float, !cir.bool
-// CIR: %[[CONST_FALSE:.*]] = cir.const #false
-// CIR: %[[SELECT_CONDITION:.*]] = cir.select if %[[IS_C_REAL_NAN]] then
%[[IS_C_IMAG_NAN]] else %[[CONST_FALSE]] : (!cir.bool, !cir.bool, !cir.bool) ->
!cir.bool
-// CIR: %[[RESULT:.*]] = cir.ternary(%[[SELECT_CONDITION]], true {
-// CIR: %[[LIBC_COMPLEX:.*]] = cir.call @__mulsc3(%[[B_REAL]], %[[B_IMAG]],
%[[A_REAL]], %[[A_IMAG]]) : (!cir.float, !cir.float, !cir.float, !cir.float) ->
!cir.complex<!cir.float>
-// CIR: cir.yield %[[LIBC_COMPLEX]] : !cir.complex<!cir.float>
-// CIR: }, false {
-// CIR: cir.yield %[[COMPLEX]] : !cir.complex<!cir.float>
-// CIR: }) : (!cir.bool) -> !cir.complex<!cir.float>
+// CIR: %[[RESULT:.*]] = cir.complex.mul %[[TMP_B]], %[[TMP_A]] range(full) :
!cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[RESULT]], %[[B_ADDR]] : !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
diff --git a/clang/test/CIR/CodeGen/complex-mul-div.cpp
b/clang/test/CIR/CodeGen/complex-mul-div.cpp
index 633080577092c..87d294ae7651f 100644
--- a/clang/test/CIR/CodeGen/complex-mul-div.cpp
+++ b/clang/test/CIR/CodeGen/complex-mul-div.cpp
@@ -1,34 +1,32 @@
// complex-range basic
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir
-complex-range=basic -Wno-unused-value -fclangir -emit-cir -mmlir
--mlir-print-ir-before=cir-canonicalize -o %t.cir %s 2>&1 | FileCheck
--check-prefix=CIR-BEFORE-BASIC %s
+
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=basic -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
-// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-AFTER-INT,CIR-AFTER-MUL-COMBINED,CIR-COMBINED
+// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-BASIC,CIR-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=basic -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s
--check-prefixes=LLVM-INT,LLVM-MUL-COMBINED,LLVM-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=basic -Wno-unused-value -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s
--check-prefixes=OGCG-INT,OGCG-MUL-COMBINED,OGCG-COMBINED
// complex-range improved
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir
-complex-range=improved -Wno-unused-value -fclangir -emit-cir -mmlir
--mlir-print-ir-before=cir-canonicalize -o %t.cir %s 2>&1 | FileCheck
--check-prefix=CIR-BEFORE-IMPROVED %s
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=improved -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
-// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-AFTER-INT,CIR-AFTER-MUL-COMBINED,CIR-COMBINED
+// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-IMPROVED,CIR-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=improved -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s
--check-prefixes=LLVM-INT,LLVM-MUL-COMBINED,LLVM-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=improved -Wno-unused-value -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s
--check-prefixes=OGCG-INT,OGCG-MUL-COMBINED,OGCG-COMBINED
// complex-range promoted
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir
-complex-range=promoted -Wno-unused-value -fclangir -emit-cir -mmlir
--mlir-print-ir-before=cir-canonicalize -o %t.cir %s 2>&1 | FileCheck
--check-prefix=CIR-BEFORE-PROMOTED %s
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=promoted -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
-// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-AFTER-INT,CIR-AFTER-MUL-COMBINED,CIR-COMBINED
+// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-PROMOTED,CIR-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=promoted -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s
--check-prefixes=LLVM-INT,LLVM-MUL-COMBINED,LLVM-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=promoted -Wno-unused-value -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s
--check-prefixes=OGCG-INT,OGCG-MUL-COMBINED,OGCG-COMBINED
// complex-range full
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir
-complex-range=full -Wno-unused-value -fclangir -emit-cir -mmlir
--mlir-print-ir-before=cir-canonicalize -o %t.cir %s 2>&1 | FileCheck
--check-prefix=CIR-BEFORE-FULL %s
+
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=full -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
-// RUN: FileCheck --input-file=%t.cir %s
--check-prefixes=CIR-AFTER-FULL,CIR-AFTER-INT,CIR-COMBINED
+// RUN: FileCheck --input-file=%t.cir %s --check-prefixes=CIR-FULL,CIR-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=full -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s
--check-prefixes=LLVM-FULL,LLVM-INT,LLVM-COMBINED
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-complex-range=full -Wno-unused-value -emit-llvm %s -o %t.ll
@@ -40,29 +38,11 @@ void foo() {
float _Complex c = a * b;
}
-// CIR-BEFORE-BASIC: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(basic) :
!cir.complex<!cir.float>
-
-// CIR-BEFORE-IMPROVED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}}
range(improved) : !cir.complex<!cir.float>
+// CIR-BASIC: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(basic) :
!cir.complex<!cir.float>
-// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}}
range(promoted) : !cir.complex<!cir.float>
+// CIR-IMPROVED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(improved) :
!cir.complex<!cir.float>
-// CIR-AFTER-MUL-COMBINED: %[[A_ADDR:.*]] = cir.alloca
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-MUL-COMBINED: %[[B_ADDR:.*]] = cir.alloca
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-MUL-COMBINED: %[[C_ADDR:.*]] = cir.alloca
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>, ["c", init]
-// CIR-AFTER-MUL-COMBINED: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER-MUL-COMBINED: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER-MUL-COMBINED: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[MUL_AR_BR:.*]] = cir.binop(mul, %[[A_REAL]],
%[[B_REAL]]) : !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[MUL_AI_BI:.*]] = cir.binop(mul, %[[A_IMAG]],
%[[B_IMAG]]) : !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[MUL_AR_BI:.*]] = cir.binop(mul, %[[A_REAL]],
%[[B_IMAG]]) : !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[MUL_AI_BR:.*]] = cir.binop(mul, %[[A_IMAG]],
%[[B_REAL]]) : !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[C_REAL:.*]] = cir.binop(sub, %[[MUL_AR_BR]],
%[[MUL_AI_BI]]) : !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[C_IMAG:.*]] = cir.binop(add, %[[MUL_AR_BI]],
%[[MUL_AI_BR]]) : !cir.float
-// CIR-AFTER-MUL-COMBINED: %[[RESULT:.*]] = cir.complex.create %[[C_REAL]],
%[[C_IMAG]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER-MUL-COMBINED: cir.store{{.*}} %[[RESULT]], %[[C_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR-PROMOTED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(promoted) :
!cir.complex<!cir.float>
// LLVM-MUL-COMBINED: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM-MUL-COMBINED: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -105,35 +85,7 @@ void foo() {
// OGCG-MUL-COMBINED: store float %[[C_REAL]], ptr %[[C_REAL_PTR]], align 4
// OGCG-MUL-COMBINED: store float %[[C_IMAG]], ptr %[[C_IMAG_PTR]], align 4
-// CIR-BEFORE-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) :
!cir.complex<!cir.float>
-
-// CIR-AFTER-FULL: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER-FULL: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b"]
-// CIR-AFTER-FULL: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["c", init]
-// CIR-AFTER-FULL: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-FULL: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-FULL: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-FULL: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER-FULL: %[[MUL_AR_BR:.*]] = cir.binop(mul, %[[A_REAL]],
%[[B_REAL]]) : !cir.float
-// CIR-AFTER-FULL: %[[MUL_AI_BI:.*]] = cir.binop(mul, %[[A_IMAG]],
%[[B_IMAG]]) : !cir.float
-// CIR-AFTER-FULL: %[[MUL_AR_BI:.*]] = cir.binop(mul, %[[A_REAL]],
%[[B_IMAG]]) : !cir.float
-// CIR-AFTER-FULL: %[[MUL_AI_BR:.*]] = cir.binop(mul, %[[A_IMAG]],
%[[B_REAL]]) : !cir.float
-// CIR-AFTER-FULL: %[[C_REAL:.*]] = cir.binop(sub, %[[MUL_AR_BR]],
%[[MUL_AI_BI]]) : !cir.float
-// CIR-AFTER-FULL: %[[C_IMAG:.*]] = cir.binop(add, %[[MUL_AR_BI]],
%[[MUL_AI_BR]]) : !cir.float
-// CIR-AFTER-FULL: %[[COMPLEX:.*]] = cir.complex.create %[[C_REAL]],
%[[C_IMAG]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER-FULL: %[[IS_C_REAL_NAN:.*]] = cir.cmp(ne, %[[C_REAL]],
%[[C_REAL]]) : !cir.float, !cir.bool
-// CIR-AFTER-FULL: %[[IS_C_IMAG_NAN:.*]] = cir.cmp(ne, %[[C_IMAG]],
%[[C_IMAG]]) : !cir.float, !cir.bool
-// CIR-AFTER-FULL: %[[CONST_FALSE:.*]] = cir.const #false
-// CIR-AFTER-FULL: %[[SELECT_CONDITION:.*]] = cir.select if %[[IS_C_REAL_NAN]]
then %[[IS_C_IMAG_NAN]] else %[[CONST_FALSE]] : (!cir.bool, !cir.bool,
!cir.bool) -> !cir.bool
-// CIR-AFTER-FULL: %[[RESULT:.*]] = cir.ternary(%[[SELECT_CONDITION]], true {
-// CIR-AFTER-FULL: %[[LIBC_COMPLEX:.*]] = cir.call @__mulsc3(%[[A_REAL]],
%[[A_IMAG]], %[[B_REAL]], %[[B_IMAG]]) : (!cir.float, !cir.float, !cir.float,
!cir.float) -> !cir.complex<!cir.float>
-// CIR-AFTER-FULL: cir.yield %[[LIBC_COMPLEX]] : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: }, false {
-// CIR-AFTER-FULL: cir.yield %[[COMPLEX]] : !cir.complex<!cir.float>
-// CIR-AFTER-FULL: }) : (!cir.bool) -> !cir.complex<!cir.float>
-// CIR-AFTER-FULL: cir.store{{.*}} %[[RESULT]], %[[C_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) :
!cir.complex<!cir.float>
// LLVM-FULL: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM-FULL: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -212,31 +164,13 @@ void foo1() {
int _Complex c = a * b;
}
-// CIR-BEFORE-BASIC: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(basic) :
!cir.complex<!s32i>
-
-// CIR-BEFORE-IMPROVED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}}
range(improved) : !cir.complex<!s32i>
+// CIR-BASIC: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(basic) :
!cir.complex<!s32i>
-// CIR-BEFORE-PROMOTED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}}
range(promoted) : !cir.complex<!s32i>
+// CIR-IMPROVED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(improved) :
!cir.complex<!s32i>
-// CIR-BEFORE-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) :
!cir.complex<!s32i>
+// CIR-PROMOTED: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(promoted) :
!cir.complex<!s32i>
-// CIR-AFTER-INT: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-AFTER-INT: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["b"]
-// CIR-AFTER-INT: %[[C_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["c", init]
-// CIR-AFTER-INT: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
-// CIR-AFTER-INT: %[[TMP_B:.*]] = cir.load{{.*}} %[[B_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
-// CIR-AFTER-INT: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-INT: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-INT: %[[B_REAL:.*]] = cir.complex.real %[[TMP_B]] :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-INT: %[[B_IMAG:.*]] = cir.complex.imag %[[TMP_B]] :
!cir.complex<!s32i> -> !s32i
-// CIR-AFTER-INT: %[[MUL_AR_BR:.*]] = cir.binop(mul, %[[A_REAL]], %[[B_REAL]])
: !s32i
-// CIR-AFTER-INT: %[[MUL_AI_BI:.*]] = cir.binop(mul, %[[A_IMAG]], %[[B_IMAG]])
: !s32i
-// CIR-AFTER-INT: %[[MUL_AR_BI:.*]] = cir.binop(mul, %[[A_REAL]], %[[B_IMAG]])
: !s32i
-// CIR-AFTER-INT: %[[MUL_AI_BR:.*]] = cir.binop(mul, %[[A_IMAG]], %[[B_REAL]])
: !s32i
-// CIR-AFTER-INT: %[[C_REAL:.*]] = cir.binop(sub, %[[MUL_AR_BR]],
%[[MUL_AI_BI]]) : !s32i
-// CIR-AFTER-INT: %[[C_IMAG:.*]] = cir.binop(add, %[[MUL_AR_BI]],
%[[MUL_AI_BR]]) : !s32i
-// CIR-AFTER-INT: %[[RESULT:.*]] = cir.complex.create %[[C_REAL]], %[[C_IMAG]]
: !s32i -> !cir.complex<!s32i>
-// CIR-AFTER-INT: cir.store{{.*}} %[[RESULT]], %[[C_ADDR]] :
!cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
+// CIR-FULL: %{{.*}} = cir.complex.mul {{.*}}, {{.*}} range(full) :
!cir.complex<!s32i>
// LLVM-INT: %[[A_ADDR:.*]] = alloca { i32, i32 }, i64 1, align 4
// LLVM-INT: %[[B_ADDR:.*]] = alloca { i32, i32 }, i64 1, align 4
@@ -324,3 +258,4 @@ void foo2() {
// OGCG-COMBINED: %[[C_IMAG_PTR:.*]] = getelementptr inbounds nuw { float,
float }, ptr %[[C_ADDR]], i32 0, i32 1
// OGCG-COMBINED: store float %[[RESULT_REAL]], ptr %[[C_REAL_PTR]], align 4
// OGCG-COMBINED: store float %[[RESULT_IMAG]], ptr %[[C_IMAG_PTR]], align 4
+
diff --git a/clang/test/CIR/CodeGen/complex-unary.cpp
b/clang/test/CIR/CodeGen/complex-unary.cpp
index 4cd81eb40597a..74134cfa6fa4d 100644
--- a/clang/test/CIR/CodeGen/complex-unary.cpp
+++ b/clang/test/CIR/CodeGen/complex-unary.cpp
@@ -1,5 +1,5 @@
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir
--mlir-print-ir-before=cir-canonicalize -o %t.cir %s 2>&1 | FileCheck
--check-prefix=CIR-BEFORE %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir
--mlir-print-ir-after=cir-lowering-prepare -o %t.cir %s 2>&1 | FileCheck
--check-prefixes=CIR-AFTER %s
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu
-Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s --check-prefixes=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value
-emit-llvm %s -o %t.ll
@@ -10,20 +10,11 @@ void foo() {
int _Complex b = ~a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
-// CIR-BEFORE: %[[COMPLEX_NOT:.*]] = cir.unary(not, %[[TMP]]) :
!cir.complex<!s32i>, !cir.complex<!s32i>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] :
!cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] : !cir.complex<!s32i>
-> !s32i
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] : !cir.complex<!s32i>
-> !s32i
-// CIR-AFTER: %[[IMAG_MINUS:.*]] = cir.unary(minus, %[[IMAG]]) : !s32i, !s32i
-// CIR-AFTER: %[[RESULT_VAL:.*]] = cir.complex.create %[[REAL]],
%[[IMAG_MINUS]] : !s32i -> !cir.complex<!s32i>
-// CIR-AFTER: cir.store{{.*}} %[[RESULT_VAL]], %[[B_ADDR]] :
!cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
+// CIR: %[[COMPLEX_NOT:.*]] = cir.unary(not, %[[TMP]]) : !cir.complex<!s32i>,
!cir.complex<!s32i>
+// CIR: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] : !cir.complex<!s32i>,
!cir.ptr<!cir.complex<!s32i>>
// LLVM: %[[A_ADDR:.*]] = alloca { i32, i32 }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { i32, i32 }, i64 1, align 4
@@ -52,20 +43,11 @@ void foo2() {
float _Complex b = ~a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_NOT:.*]] = cir.unary(not, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG_MINUS:.*]] = cir.unary(minus, %[[IMAG]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[RESULT_VAL:.*]] = cir.complex.create %[[REAL]],
%[[IMAG_MINUS]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[RESULT_VAL]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_NOT:.*]] = cir.unary(not, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_NOT]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -94,22 +76,12 @@ void foo3() {
float _Complex b = a++;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_INC:.*]] = cir.unary(inc, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_INC:.*]] = cir.unary(inc, %[[REAL]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[NEW_COMPLEX:.*]] = cir.complex.create %[[REAL_INC]],
%[[IMAG]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_INC:.*]] = cir.unary(inc, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -143,22 +115,12 @@ void foo4() {
float _Complex b = ++a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_INC:.*]] = cir.unary(inc, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_INC]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_INC:.*]] = cir.unary(inc, %[[REAL]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[NEW_COMPLEX:.*]] = cir.complex.create %[[REAL_INC]],
%[[IMAG]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_INC:.*]] = cir.unary(inc, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_INC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: cir.store{{.*}} %[[COMPLEX_INC]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -192,22 +154,12 @@ void foo5() {
float _Complex b = a--;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_DEC:.*]] = cir.unary(dec, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_DEC:.*]] = cir.unary(dec, %[[REAL]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[NEW_COMPLEX:.*]] = cir.complex.create %[[REAL_DEC]],
%[[IMAG]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_DEC:.*]] = cir.unary(dec, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: cir.store{{.*}} %[[TMP]], %[[B_ADDR]] : !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -241,22 +193,12 @@ void foo6() {
float _Complex b = --a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_DEC:.*]] = cir.unary(dec, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_DEC]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_DEC:.*]] = cir.unary(dec, %[[REAL]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[NEW_COMPLEX:.*]] = cir.complex.create %[[REAL_DEC]],
%[[IMAG]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_DEC:.*]] = cir.unary(dec, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_DEC]], %[[A_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: cir.store{{.*}} %[[COMPLEX_DEC]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -290,21 +232,11 @@ void foo7() {
float _Complex b = +a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_PLUS:.*]] = cir.unary(plus, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_PLUS]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_PLUS:.*]] = cir.unary(plus, %[[REAL]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[IMAG_PLUS:.*]] = cir.unary(plus, %[[IMAG]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[NEW_COMPLEX:.*]] = cir.complex.create %[[REAL_PLUS]],
%[[IMAG_PLUS]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_PLUS:.*]] = cir.unary(plus, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_PLUS]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
@@ -331,21 +263,11 @@ void foo8() {
float _Complex b = -a;
}
-// CIR-BEFORE: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-BEFORE: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-BEFORE: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-BEFORE: %[[COMPLEX_MINUS:.*]] = cir.unary(minus, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
-// CIR-BEFORE: cir.store{{.*}} %[[COMPLEX_MINUS]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
-
-// CIR-AFTER: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
-// CIR-AFTER: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
-// CIR-AFTER: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
-// CIR-AFTER: %[[REAL:.*]] = cir.complex.real %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[IMAG:.*]] = cir.complex.imag %[[TMP]] :
!cir.complex<!cir.float> -> !cir.float
-// CIR-AFTER: %[[REAL_MINUS:.*]] = cir.unary(minus, %[[REAL]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[IMAG_MINUS:.*]] = cir.unary(minus, %[[IMAG]]) : !cir.float,
!cir.float
-// CIR-AFTER: %[[NEW_COMPLEX:.*]] = cir.complex.create %[[REAL_MINUS]],
%[[IMAG_MINUS]] : !cir.float -> !cir.complex<!cir.float>
-// CIR-AFTER: cir.store{{.*}} %[[NEW_COMPLEX]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
+// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a"]
+// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["b", init]
+// CIR: %[[TMP:.*]] = cir.load{{.*}} %[[A_ADDR]] :
!cir.ptr<!cir.complex<!cir.float>>, !cir.complex<!cir.float>
+// CIR: %[[COMPLEX_MINUS:.*]] = cir.unary(minus, %[[TMP]]) :
!cir.complex<!cir.float>, !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[COMPLEX_MINUS]], %[[B_ADDR]] :
!cir.complex<!cir.float>, !cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
// LLVM: %[[B_ADDR:.*]] = alloca { float, float }, i64 1, align 4
diff --git a/clang/test/CIR/CodeGen/complex.cpp
b/clang/test/CIR/CodeGen/complex.cpp
index bd7de9a3a5039..bb1ab7930a86b 100644
--- a/clang/test/CIR/CodeGen/complex.cpp
+++ b/clang/test/CIR/CodeGen/complex.cpp
@@ -787,8 +787,7 @@ void foo30() {
// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>, ["a", init]
// CIR: %[[CONST_1F:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
-// CIR: %[[CONST_0F:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
-// CIR: %[[COMPLEX:.*]] = cir.complex.create %[[CONST_1F]], %[[CONST_0F]] :
!cir.float -> !cir.complex<!cir.float>
+// CIR: %[[COMPLEX:.*]] = cir.cast(float_to_complex, %[[CONST_1F]] :
!cir.float), !cir.complex<!cir.float>
// CIR: cir.store{{.*}} %[[COMPLEX]], %[[A_ADDR]] : !cir.complex<!cir.float>,
!cir.ptr<!cir.complex<!cir.float>>
// LLVM: %[[A_ADDR:.*]] = alloca { float, float }, i64 1, align 4
diff --git a/clang/test/CIR/CodeGen/destructors.cpp
b/clang/test/CIR/CodeGen/destructors.cpp
index fde0732a4352f..a6fecbbdaa092 100644
--- a/clang/test/CIR/CodeGen/destructors.cpp
+++ b/clang/test/CIR/CodeGen/destructors.cpp
@@ -61,41 +61,31 @@ void test_array_destructor() {
array_element arr[5]{};
}
-// CIR: cir.func dso_local @_Z21test_array_destructorv()
+// CIR: cir.func dso_local @_Z21test_array_destructorv() {
// CIR: %[[ARR:.*]] = cir.alloca !cir.array<!rec_array_element x 5>,
!cir.ptr<!cir.array<!rec_array_element x 5>>, ["arr", init]
// CIR: %[[ARR_PTR:.*]] = cir.alloca !cir.ptr<!rec_array_element>,
!cir.ptr<!cir.ptr<!rec_array_element>>, ["arrayinit.temp", init]
-// CIR: %[[BEGIN:.*]] = cir.cast(array_to_ptrdecay, %[[ARR]] :
!cir.ptr<!cir.array<!rec_array_element x 5>>)
-// CIR: cir.store{{.*}} %[[BEGIN]], %[[ARR_PTR]]
+// CIR: %[[BEGIN:.*]] = cir.cast(array_to_ptrdecay, %[[ARR]] :
!cir.ptr<!cir.array<!rec_array_element x 5>>), !cir.ptr<!rec_array_element>
+// CIR: cir.store{{.*}} %[[BEGIN]], %[[ARR_PTR]] :
!cir.ptr<!rec_array_element>, !cir.ptr<!cir.ptr<!rec_array_element>>
// CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !s64i
-// CIR: %[[ARR_END:.*]] = cir.ptr_stride(%[[BEGIN]] :
!cir.ptr<!rec_array_element>, %[[FIVE]] : !s64i)
+// CIR: %[[ARR_END:.*]] = cir.ptr_stride(%[[BEGIN]] :
!cir.ptr<!rec_array_element>, %3 : !s64i), !cir.ptr<!rec_array_element>
// CIR: cir.do {
-// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]]
+// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]] :
!cir.ptr<!cir.ptr<!rec_array_element>>, !cir.ptr<!rec_array_element>
// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
-// CIR: %[[ARR_NEXT:.*]] = cir.ptr_stride(%[[ARR_CUR]] :
!cir.ptr<!rec_array_element>, %[[ONE]] : !s64i)
+// CIR: %[[ARR_NEXT:.*]] = cir.ptr_stride(%[[ARR_CUR]] :
!cir.ptr<!rec_array_element>, %6 : !s64i), !cir.ptr<!rec_array_element>
// CIR: cir.store{{.*}} %[[ARR_NEXT]], %[[ARR_PTR]] :
!cir.ptr<!rec_array_element>, !cir.ptr<!cir.ptr<!rec_array_element>>
// CIR: cir.yield
// CIR: } while {
-// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]]
-// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[ARR_CUR]], %[[ARR_END]])
+// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]] :
!cir.ptr<!cir.ptr<!rec_array_element>>, !cir.ptr<!rec_array_element>
+// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[ARR_CUR]], %[[ARR_END]]) :
!cir.ptr<!rec_array_element>, !cir.bool
// CIR: cir.condition(%[[CMP]])
// CIR: }
-// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !u64i
-// CIR: %[[BEGIN:.*]] = cir.cast(array_to_ptrdecay, %[[ARR]] :
!cir.ptr<!cir.array<!rec_array_element x 5>>)
-// CIR: %[[END:.*]] = cir.ptr_stride(%[[BEGIN]] :
!cir.ptr<!rec_array_element>, %[[FOUR]] : !u64i)
-// CIR: %[[ARR_PTR:.*]] = cir.alloca !cir.ptr<!rec_array_element>,
!cir.ptr<!cir.ptr<!rec_array_element>>, ["__array_idx"]
-// CIR: cir.store %[[END]], %[[ARR_PTR]]
-// CIR: cir.do {
-// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]]
-// CIR: cir.call @_ZN13array_elementD1Ev(%[[ARR_CUR]]) nothrow :
(!cir.ptr<!rec_array_element>) -> ()
-// CIR: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
-// CIR: %[[ARR_NEXT:.*]] = cir.ptr_stride(%[[ARR_CUR]] :
!cir.ptr<!rec_array_element>, %[[NEG_ONE]] : !s64i)
-// CIR: cir.store %[[ARR_NEXT]], %[[ARR_PTR]]
+// CIR: cir.array.dtor %[[ARR]] : !cir.ptr<!cir.array<!rec_array_element x
5>> {
+// CIR: ^bb0(%{{.*}}: !cir.ptr<!rec_array_element> {{.*}}):
+// CIR: cir.call @_ZN13array_elementD1Ev(%{{.*}}) nothrow :
(!cir.ptr<!rec_array_element>) -> ()
// CIR: cir.yield
-// CIR: } while {
-// CIR: %[[ARR_CUR:.*]] = cir.load{{.*}} %[[ARR_PTR]]
-// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[ARR_CUR]], %[[BEGIN]])
-// CIR: cir.condition(%[[CMP]])
// CIR: }
+// CIR: cir.return
+// CIR: }
// LLVM: define{{.*}} void @_Z21test_array_destructorv()
// LLVM: %[[ARR:.*]] = alloca [5 x %struct.array_element]
diff --git a/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
b/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
index 0b58bae9239b2..27daa488d8b64 100644
--- a/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/combined-private-clause.cpp
@@ -15,53 +15,29 @@ struct HasDtor {
~HasDtor();
};
-// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor :
!cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
+// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor :
!cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>>
{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>,
!cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>,
!cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
-// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>>
{{.*}}):
-// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<4> : !u64i
-// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ARG]] :
!cir.ptr<!cir.array<!rec_HasDtor x 5>>), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] :
!cir.ptr<!rec_HasDtor>, %[[LAST_IDX]] : !u64i), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>, ["__array_idx"]
-// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>
-// CHECK-NEXT: cir.do {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ELEM_LOAD]]) nothrow :
(!cir.ptr<!rec_HasDtor>) -> ()
-// CHECK-NEXT: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
-// CHECK-NEXT: %[[PREVELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] :
!cir.ptr<!rec_HasDtor>, %[[NEG_ONE]] : !s64i), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: cir.store %[[PREVELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>
-// CHECK-NEXT: cir.yield
-// CHECK-NEXT: } while {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[ARRPTR]]) :
!cir.ptr<!rec_HasDtor>, !cir.bool
-// CHECK-NEXT: cir.condition(%[[CMP]])
-// CHECK-NEXT: }
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
+// CHECK-NEXT: cir.array.dtor %[[ARG]] : !cir.ptr<!cir.array<!rec_HasDtor x
5>> {
+// CHECK-NEXT: ^bb0(%[[ARG1:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
+// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ARG1]]) nothrow :
(!cir.ptr<!rec_HasDtor>) -> ()
+// CHECK-NEXT: cir.yield
+// CHECK-NEXT: }
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_14NonDefaultCtor :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
{{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x
5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init",
init]
-// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
-// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ALLOCA]] :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>), !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[LAST_ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] :
!cir.ptr<!rec_NonDefaultCtor>, %[[LAST_IDX]] : !u64i),
!cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_NonDefaultCtor>,
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, ["__array_idx"]
-// CHECK-NEXT: cir.store %[[ARRPTR]], %[[ITR]] :
!cir.ptr<!rec_NonDefaultCtor>, !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
-// CHECK-NEXT: cir.do {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ELEM_LOAD]]) :
(!cir.ptr<!rec_NonDefaultCtor>) -> ()
-// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !u64i
-// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] :
!cir.ptr<!rec_NonDefaultCtor>, %[[ONE_CONST]] : !u64i),
!cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_NonDefaultCtor>,
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
-// CHECK-NEXT: cir.yield
-// CHECK-NEXT: } while {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[LAST_ELEM]]) :
!cir.ptr<!rec_NonDefaultCtor>, !cir.bool
-// CHECK-NEXT: cir.condition(%[[CMP]])
-// CHECK-NEXT: }
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x
5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init",
init]
+// CHECK-NEXT: cir.array.ctor %[[ALLOCA]] :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {
+// CHECK-NEXT: ^bb0(%[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
+// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ARG1]]) :
(!cir.ptr<!rec_NonDefaultCtor>) -> ()
+// CHECK-NEXT: cir.yield
+// CHECK-NEXT: }
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_13CopyConstruct :
!cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
diff --git a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
index 940bf53e7ece4..9d027eb2f261a 100644
--- a/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/compute-private-clause.cpp
@@ -15,53 +15,29 @@ struct HasDtor {
~HasDtor();
};
-// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor :
!cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
+// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor :
!cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>>
{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>,
!cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>,
!cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
-// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>>
{{.*}}):
-// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<4> : !u64i
-// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ARG]] :
!cir.ptr<!cir.array<!rec_HasDtor x 5>>), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] :
!cir.ptr<!rec_HasDtor>, %[[LAST_IDX]] : !u64i), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>, ["__array_idx"]
-// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>
-// CHECK-NEXT: cir.do {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ELEM_LOAD]]) nothrow :
(!cir.ptr<!rec_HasDtor>) -> ()
-// CHECK-NEXT: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
-// CHECK-NEXT: %[[PREVELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] :
!cir.ptr<!rec_HasDtor>, %[[NEG_ONE]] : !s64i), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: cir.store %[[PREVELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>
-// CHECK-NEXT: cir.yield
-// CHECK-NEXT: } while {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[ARRPTR]]) :
!cir.ptr<!rec_HasDtor>, !cir.bool
-// CHECK-NEXT: cir.condition(%[[CMP]])
-// CHECK-NEXT: }
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
+// CHECK-NEXT: cir.array.dtor %[[ARG]] : !cir.ptr<!cir.array<!rec_HasDtor x
5>> {
+// CHECK-NEXT: ^bb0(%[[ARG1:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
+// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ARG1]]) nothrow :
(!cir.ptr<!rec_HasDtor>) -> ()
+// CHECK-NEXT: cir.yield
+// CHECK-NEXT: }
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_14NonDefaultCtor :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
{{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x
5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init",
init]
-// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
-// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ALLOCA]] :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>), !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[LAST_ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] :
!cir.ptr<!rec_NonDefaultCtor>, %[[LAST_IDX]] : !u64i),
!cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_NonDefaultCtor>,
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, ["__array_idx"]
-// CHECK-NEXT: cir.store %[[ARRPTR]], %[[ITR]] :
!cir.ptr<!rec_NonDefaultCtor>, !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
-// CHECK-NEXT: cir.do {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ELEM_LOAD]]) :
(!cir.ptr<!rec_NonDefaultCtor>) -> ()
-// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !u64i
-// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] :
!cir.ptr<!rec_NonDefaultCtor>, %[[ONE_CONST]] : !u64i),
!cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_NonDefaultCtor>,
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
-// CHECK-NEXT: cir.yield
-// CHECK-NEXT: } while {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[LAST_ELEM]]) :
!cir.ptr<!rec_NonDefaultCtor>, !cir.bool
-// CHECK-NEXT: cir.condition(%[[CMP]])
-// CHECK-NEXT: }
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x
5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init",
init]
+// CHECK-NEXT: cir.array.ctor %[[ALLOCA]] :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {
+// CHECK-NEXT: ^bb0(%[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
+// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ARG1]]) :
(!cir.ptr<!rec_NonDefaultCtor>) -> ()
+// CHECK-NEXT: cir.yield
+// CHECK-NEXT: }
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_13CopyConstruct :
!cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
diff --git a/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
b/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
index 435a0c9157603..d1c64b6a6fdcb 100644
--- a/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
+++ b/clang/test/CIR/CodeGenOpenACC/loop-private-clause.cpp
@@ -15,53 +15,29 @@ struct HasDtor {
~HasDtor();
};
-// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor :
!cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
+// CHECK: acc.private.recipe @privatization__ZTSA5_7HasDtor :
!cir.ptr<!cir.array<!rec_HasDtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>>
{{.*}}):
-// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>,
!cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: cir.alloca !cir.array<!rec_HasDtor x 5>,
!cir.ptr<!cir.array<!rec_HasDtor x 5>>, ["openacc.private.init"]
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: } destroy {
-// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_HasDtor x 5>>
{{.*}}):
-// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<4> : !u64i
-// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ARG]] :
!cir.ptr<!cir.array<!rec_HasDtor x 5>>), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] :
!cir.ptr<!rec_HasDtor>, %[[LAST_IDX]] : !u64i), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>, ["__array_idx"]
-// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>
-// CHECK-NEXT: cir.do {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ELEM_LOAD]]) nothrow :
(!cir.ptr<!rec_HasDtor>) -> ()
-// CHECK-NEXT: %[[NEG_ONE:.*]] = cir.const #cir.int<-1> : !s64i
-// CHECK-NEXT: %[[PREVELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] :
!cir.ptr<!rec_HasDtor>, %[[NEG_ONE]] : !s64i), !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: cir.store %[[PREVELEM]], %[[ITR]] : !cir.ptr<!rec_HasDtor>,
!cir.ptr<!cir.ptr<!rec_HasDtor>>
-// CHECK-NEXT: cir.yield
-// CHECK-NEXT: } while {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_HasDtor>>, !cir.ptr<!rec_HasDtor>
-// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[ARRPTR]]) :
!cir.ptr<!rec_HasDtor>, !cir.bool
-// CHECK-NEXT: cir.condition(%[[CMP]])
-// CHECK-NEXT: }
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: ^bb0(%arg0: !cir.ptr<!cir.array<!rec_HasDtor x 5>> {{.*}}):
+// CHECK-NEXT: cir.array.dtor %[[ARG]] : !cir.ptr<!cir.array<!rec_HasDtor x
5>> {
+// CHECK-NEXT: ^bb0(%[[ARG1:.*]]: !cir.ptr<!rec_HasDtor> {{.*}}):
+// CHECK-NEXT: cir.call @_ZN7HasDtorD1Ev(%[[ARG1]]) nothrow :
(!cir.ptr<!rec_HasDtor>) -> ()
+// CHECK-NEXT: cir.yield
+// CHECK-NEXT: }
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_14NonDefaultCtor :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> init {
// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>
{{.*}}):
-// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x
5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init",
init]
-// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !u64i
-// CHECK-NEXT: %[[ARRPTR:.*]] = cir.cast(array_to_ptrdecay, %[[ALLOCA]] :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>), !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[LAST_ELEM:.*]] = cir.ptr_stride(%[[ARRPTR]] :
!cir.ptr<!rec_NonDefaultCtor>, %[[LAST_IDX]] : !u64i),
!cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !cir.ptr<!rec_NonDefaultCtor>,
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, ["__array_idx"]
-// CHECK-NEXT: cir.store %[[ARRPTR]], %[[ITR]] :
!cir.ptr<!rec_NonDefaultCtor>, !cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
-// CHECK-NEXT: cir.do {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ELEM_LOAD]]) :
(!cir.ptr<!rec_NonDefaultCtor>) -> ()
-// CHECK-NEXT: %[[ONE_CONST:.*]] = cir.const #cir.int<1> : !u64i
-// CHECK-NEXT: %[[ELEM:.*]] = cir.ptr_stride(%[[ELEM_LOAD]] :
!cir.ptr<!rec_NonDefaultCtor>, %[[ONE_CONST]] : !u64i),
!cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: cir.store %[[ELEM]], %[[ITR]] : !cir.ptr<!rec_NonDefaultCtor>,
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>
-// CHECK-NEXT: cir.yield
-// CHECK-NEXT: } while {
-// CHECK-NEXT: %[[ELEM_LOAD:.*]] = cir.load %[[ITR]] :
!cir.ptr<!cir.ptr<!rec_NonDefaultCtor>>, !cir.ptr<!rec_NonDefaultCtor>
-// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[ELEM_LOAD]], %[[LAST_ELEM]]) :
!cir.ptr<!rec_NonDefaultCtor>, !cir.bool
-// CHECK-NEXT: cir.condition(%[[CMP]])
-// CHECK-NEXT: }
-// CHECK-NEXT: acc.yield
+// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_NonDefaultCtor x
5>, !cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>>, ["openacc.private.init",
init]
+// CHECK-NEXT: cir.array.ctor %[[ALLOCA]] :
!cir.ptr<!cir.array<!rec_NonDefaultCtor x 5>> {
+// CHECK-NEXT: ^bb0(%[[ARG1:.*]]: !cir.ptr<!rec_NonDefaultCtor> {{.*}}):
+// CHECK-NEXT: cir.call @_ZN14NonDefaultCtorC1Ev(%[[ARG1]]) :
(!cir.ptr<!rec_NonDefaultCtor>) -> ()
+// CHECK-NEXT: cir.yield
+// CHECK-NEXT: }
+// CHECK-NEXT: acc.yield
// CHECK-NEXT: }
//
// CHECK-NEXT: acc.private.recipe @privatization__ZTSA5_13CopyConstruct :
!cir.ptr<!cir.array<!rec_CopyConstruct x 5>> init {
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
