[libcxx-commits] [lldb] [compiler-rt] [libc] [clang] [libcxx] [clang-tools-extra] [llvm] [mlir] [openmp] [flang] [OpenMP] atomic compare fail : Codegen support (PR #75709)
via libcxx-commits
libcxx-commits at lists.llvm.org
Tue Jan 2 01:41:24 PST 2024
https://github.com/SunilKuravinakop updated https://github.com/llvm/llvm-project/pull/75709
>From fe931d64741f427629407bca3e68a61bec6f2b67 Mon Sep 17 00:00:00 2001
From: Sunil Kuravinakop <kuravina at pe28vega.us.cray.com>
Date: Sat, 16 Dec 2023 11:43:35 -0600
Subject: [PATCH 1/3] Adding parameter to fail clause (i.e. memory order
clause) for codegen.
Changes to be committed:
modified: clang/lib/CodeGen/CGStmtOpenMP.cpp
---
clang/lib/CodeGen/CGStmtOpenMP.cpp | 51 +++++++++++++++++++++++++++---
1 file changed, 47 insertions(+), 4 deletions(-)
diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp
index 478d6dbf9ca81d..a502db7ac3a5e0 100644
--- a/clang/lib/CodeGen/CGStmtOpenMP.cpp
+++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp
@@ -6516,10 +6516,6 @@ static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
IsPostfixUpdate, IsFailOnly, Loc);
break;
}
- case OMPC_fail: {
- //TODO
- break;
- }
default:
llvm_unreachable("Clause is not allowed in 'omp atomic'.");
}
@@ -6527,6 +6523,8 @@ static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
llvm::AtomicOrdering AO = llvm::AtomicOrdering::Monotonic;
+ // Fail Memory Clause Ordering.
+ llvm::AtomicOrdering FO = llvm::AtomicOrdering::Monotonic;
bool MemOrderingSpecified = false;
if (S.getSingleClause<OMPSeqCstClause>()) {
AO = llvm::AtomicOrdering::SequentiallyConsistent;
@@ -6580,6 +6578,51 @@ void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
}
}
+ if (KindsEncountered.contains(OMPC_compare) &&
+ KindsEncountered.contains(OMPC_fail)) {
+ Kind = OMPC_compare;
+ const OMPFailClause *fC = S.getSingleClause<OMPFailClause>();
+ if (fC) {
+ OpenMPClauseKind fP = fC->getFailParameter();
+ if (fP == llvm::omp::OMPC_relaxed)
+ FO = llvm::AtomicOrdering::Monotonic;
+ else if (fP == llvm::omp::OMPC_acquire)
+ FO = llvm::AtomicOrdering::Acquire;
+ else if (fP == llvm::omp::OMPC_seq_cst)
+ FO = llvm::AtomicOrdering::SequentiallyConsistent;
+ }
+
+ // Logic for 2 memory order clauses in the atomic directive.
+ // e.g. #pragma omp atomic compare capture release fail(seq_cst)
+ // if(x > e) { x = j; } else { k = x; }
+ // To provide the Memory Order clause in atomic directive
+ // there are 2 instructions in LLVM IR atomicrmw & cmpxchgl.
+ // 1) atomicrmw can use only 1 memory order clause and can contain the
+ // operator in if condition.
+ // 2) cmpxchgl can use 2 memory order clauses : Success memory order clause
+ // & fail parameter memory clause. However, cmpxchgl uses only equality
+ // operator.
+ // We need to change atomicrmw to contain the fail parameter clause or add
+ // a new instruction in LLVM IR. Changes in LLVM IR need to be done
+ // seperately and at present we will use the logic of using the more strict
+ // memory order clause of success or fail memory order clauses for the
+ // atomicrmw. The following logic takes care of this change in the memory
+ // order clause.
+ if (AO == llvm::AtomicOrdering::Monotonic)
+ AO = FO;
+ else if (FO == llvm::AtomicOrdering::Monotonic)
+ AO = AO;
+ else if (AO == llvm::AtomicOrdering::SequentiallyConsistent ||
+ FO == llvm::AtomicOrdering::SequentiallyConsistent)
+ AO = llvm::AtomicOrdering::SequentiallyConsistent;
+ else if (AO == llvm::AtomicOrdering::Acquire)
+ AO = llvm::AtomicOrdering::Acquire;
+ else if (AO == llvm::AtomicOrdering::Release)
+ AO = llvm::AtomicOrdering::AcquireRelease;
+ else if (AO == llvm::AtomicOrdering::AcquireRelease)
+ AO = llvm::AtomicOrdering::AcquireRelease;
+ }
+
LexicalScope Scope(*this, S.getSourceRange());
EmitStopPoint(S.getAssociatedStmt());
emitOMPAtomicExpr(*this, Kind, AO, S.isPostfixUpdate(), S.getX(), S.getV(),
>From 9cc33631c89c4fd4dce8a274fed700febe5dfa90 Mon Sep 17 00:00:00 2001
From: Sunil Kuravinakop <kuravina at pe28vega.us.cray.com>
Date: Tue, 19 Dec 2023 23:49:03 -0600
Subject: [PATCH 2/3] 1) Since the {if(x == e) {x = v;} else {d = x;}}
results in generation of cmpxchg in the LLVM IR, the memory order clause in
"fail" clause is now being added. In case of other operators ">" & "<"
e.g. dx = dx > de ? de : dx; result in atomicrmw in the LLVM IR.
"atomicrmw" can have only one memory order clause. Currently, the memory
order clause is ignored. 2) Test cases for codegen 3) In SemaOpenMP.cpp,
added EncounteredAtomicKinds.contains(OMPC_compare) instead of AtomicKind
== OMPC_compare. This was to accomodate where AtomicKind is OMPC_capture.
Changes to be committed:
modified: clang/lib/CodeGen/CGStmtOpenMP.cpp
modified: clang/lib/Sema/SemaOpenMP.cpp
modified: clang/test/OpenMP/atomic_compare_codegen.cpp
modified: llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
modified: llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
---
clang/lib/CodeGen/CGStmtOpenMP.cpp | 78 ++++------
clang/lib/Sema/SemaOpenMP.cpp | 2 +-
clang/test/OpenMP/atomic_compare_codegen.cpp | 144 ++++++++++++++++++
.../llvm/Frontend/OpenMP/OMPIRBuilder.h | 7 +
llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp | 12 +-
5 files changed, 190 insertions(+), 53 deletions(-)
diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp
index e2caa0d7742126..225f13cb8c8869 100644
--- a/clang/lib/CodeGen/CGStmtOpenMP.cpp
+++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp
@@ -6406,13 +6406,11 @@ static void emitOMPAtomicCaptureExpr(CodeGenFunction &CGF,
}
}
-static void emitOMPAtomicCompareExpr(CodeGenFunction &CGF,
- llvm::AtomicOrdering AO, const Expr *X,
- const Expr *V, const Expr *R,
- const Expr *E, const Expr *D,
- const Expr *CE, bool IsXBinopExpr,
- bool IsPostfixUpdate, bool IsFailOnly,
- SourceLocation Loc) {
+static void emitOMPAtomicCompareExpr(
+ CodeGenFunction &CGF, llvm::AtomicOrdering AO, llvm::AtomicOrdering FailAO,
+ const Expr *X, const Expr *V, const Expr *R, const Expr *E, const Expr *D,
+ const Expr *CE, bool IsXBinopExpr, bool IsPostfixUpdate, bool IsFailOnly,
+ SourceLocation Loc) {
llvm::OpenMPIRBuilder &OMPBuilder =
CGF.CGM.getOpenMPRuntime().getOMPBuilder();
@@ -6477,13 +6475,21 @@ static void emitOMPAtomicCompareExpr(CodeGenFunction &CGF,
R->getType().isVolatileQualified()};
}
- CGF.Builder.restoreIP(OMPBuilder.createAtomicCompare(
- CGF.Builder, XOpVal, VOpVal, ROpVal, EVal, DVal, AO, Op, IsXBinopExpr,
- IsPostfixUpdate, IsFailOnly));
+ if (FailAO == llvm::AtomicOrdering::NotAtomic) {
+ // fail clause was not mentionend on the
+ // "#pragma omp atomic compare" construct.
+ CGF.Builder.restoreIP(OMPBuilder.createAtomicCompare(
+ CGF.Builder, XOpVal, VOpVal, ROpVal, EVal, DVal, AO, Op, IsXBinopExpr,
+ IsPostfixUpdate, IsFailOnly));
+ } else
+ CGF.Builder.restoreIP(OMPBuilder.createAtomicCompare(
+ CGF.Builder, XOpVal, VOpVal, ROpVal, EVal, DVal, AO, Op, IsXBinopExpr,
+ IsPostfixUpdate, IsFailOnly, FailAO));
}
static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
- llvm::AtomicOrdering AO, bool IsPostfixUpdate,
+ llvm::AtomicOrdering AO,
+ llvm::AtomicOrdering FailAO, bool IsPostfixUpdate,
const Expr *X, const Expr *V, const Expr *R,
const Expr *E, const Expr *UE, const Expr *D,
const Expr *CE, bool IsXLHSInRHSPart,
@@ -6504,8 +6510,8 @@ static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
IsXLHSInRHSPart, Loc);
break;
case OMPC_compare: {
- emitOMPAtomicCompareExpr(CGF, AO, X, V, R, E, D, CE, IsXLHSInRHSPart,
- IsPostfixUpdate, IsFailOnly, Loc);
+ emitOMPAtomicCompareExpr(CGF, AO, FailAO, X, V, R, E, D, CE,
+ IsXLHSInRHSPart, IsPostfixUpdate, IsFailOnly, Loc);
break;
}
default:
@@ -6516,7 +6522,7 @@ static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
llvm::AtomicOrdering AO = llvm::AtomicOrdering::Monotonic;
// Fail Memory Clause Ordering.
- llvm::AtomicOrdering FO = llvm::AtomicOrdering::Monotonic;
+ llvm::AtomicOrdering FailAO = llvm::AtomicOrdering::NotAtomic;
bool MemOrderingSpecified = false;
if (S.getSingleClause<OMPSeqCstClause>()) {
AO = llvm::AtomicOrdering::SequentiallyConsistent;
@@ -6577,50 +6583,20 @@ void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
if (fC) {
OpenMPClauseKind fP = fC->getFailParameter();
if (fP == llvm::omp::OMPC_relaxed)
- FO = llvm::AtomicOrdering::Monotonic;
+ FailAO = llvm::AtomicOrdering::Monotonic;
else if (fP == llvm::omp::OMPC_acquire)
- FO = llvm::AtomicOrdering::Acquire;
+ FailAO = llvm::AtomicOrdering::Acquire;
else if (fP == llvm::omp::OMPC_seq_cst)
- FO = llvm::AtomicOrdering::SequentiallyConsistent;
+ FailAO = llvm::AtomicOrdering::SequentiallyConsistent;
}
-
- // Logic for 2 memory order clauses in the atomic directive.
- // e.g. #pragma omp atomic compare capture release fail(seq_cst)
- // if(x > e) { x = j; } else { k = x; }
- // To provide the Memory Order clause in atomic directive
- // there are 2 instructions in LLVM IR atomicrmw & cmpxchgl.
- // 1) atomicrmw can use only 1 memory order clause and can contain the
- // operator in if condition.
- // 2) cmpxchgl can use 2 memory order clauses : Success memory order clause
- // & fail parameter memory clause. However, cmpxchgl uses only equality
- // operator.
- // We need to change atomicrmw to contain the fail parameter clause or add
- // a new instruction in LLVM IR. Changes in LLVM IR need to be done
- // seperately and at present we will use the logic of using the more strict
- // memory order clause of success or fail memory order clauses for the
- // atomicrmw. The following logic takes care of this change in the memory
- // order clause.
- if (AO == llvm::AtomicOrdering::Monotonic)
- AO = FO;
- else if (FO == llvm::AtomicOrdering::Monotonic)
- AO = AO;
- else if (AO == llvm::AtomicOrdering::SequentiallyConsistent ||
- FO == llvm::AtomicOrdering::SequentiallyConsistent)
- AO = llvm::AtomicOrdering::SequentiallyConsistent;
- else if (AO == llvm::AtomicOrdering::Acquire)
- AO = llvm::AtomicOrdering::Acquire;
- else if (AO == llvm::AtomicOrdering::Release)
- AO = llvm::AtomicOrdering::AcquireRelease;
- else if (AO == llvm::AtomicOrdering::AcquireRelease)
- AO = llvm::AtomicOrdering::AcquireRelease;
}
LexicalScope Scope(*this, S.getSourceRange());
EmitStopPoint(S.getAssociatedStmt());
- emitOMPAtomicExpr(*this, Kind, AO, S.isPostfixUpdate(), S.getX(), S.getV(),
- S.getR(), S.getExpr(), S.getUpdateExpr(), S.getD(),
- S.getCondExpr(), S.isXLHSInRHSPart(), S.isFailOnly(),
- S.getBeginLoc());
+ emitOMPAtomicExpr(*this, Kind, AO, FailAO, S.isPostfixUpdate(), S.getX(),
+ S.getV(), S.getR(), S.getExpr(), S.getUpdateExpr(),
+ S.getD(), S.getCondExpr(), S.isXLHSInRHSPart(),
+ S.isFailOnly(), S.getBeginLoc());
}
static void emitCommonOMPTargetDirective(CodeGenFunction &CGF,
diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp
index e400f248d15aa3..acbc1d5dad08c3 100644
--- a/clang/lib/Sema/SemaOpenMP.cpp
+++ b/clang/lib/Sema/SemaOpenMP.cpp
@@ -12683,7 +12683,7 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
break;
}
case OMPC_fail: {
- if (AtomicKind != OMPC_compare) {
+ if (!EncounteredAtomicKinds.contains(OMPC_compare)) {
Diag(C->getBeginLoc(), diag::err_omp_atomic_fail_no_compare)
<< SourceRange(C->getBeginLoc(), C->getEndLoc());
return StmtError();
diff --git a/clang/test/OpenMP/atomic_compare_codegen.cpp b/clang/test/OpenMP/atomic_compare_codegen.cpp
index 43607cc65ad9b5..03e5081a5c1d8a 100644
--- a/clang/test/OpenMP/atomic_compare_codegen.cpp
+++ b/clang/test/OpenMP/atomic_compare_codegen.cpp
@@ -13806,6 +13806,64 @@ double dxevd() {
return dv;
}
+
+double fail_dxevd() {
+ double dx, dv, de, dd;
+
+#pragma omp atomic compare capture relaxed fail(relaxed)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture acquire fail(relaxed)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture release fail(relaxed)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture acq_rel fail(relaxed)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture seq_cst fail(relaxed)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture relaxed fail(acquire)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture acquire fail(acquire)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture release fail(acquire)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture acq_rel fail(acquire)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture seq_cst fail(acquire)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture relaxed fail(seq_cst)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture acquire fail(seq_cst)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture release fail(seq_cst)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture acq_rel fail(seq_cst)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare capture seq_cst fail(seq_cst)
+ {if(dx == de) { dx = dv; } else { dd = dx; }}
+
+#pragma omp atomic compare seq_cst fail(acquire)
+ dx = dx < de ? de : dx;
+
+#pragma omp atomic compare relaxed fail(seq_cst)
+ dx = dx > de ? de : dx;
+
+ return dx;
+}
+
#endif
// CHECK-LABEL: @foo(
// CHECK-NEXT: entry:
@@ -61966,3 +62024,89 @@ double dxevd() {
// SIMD-ONLY0-NEXT: [[TMP180:%.*]] = load double, ptr [[DV]], align 8
// SIMD-ONLY0-NEXT: ret double [[TMP180]]
//
+// CHECK-LABEL: {{.+}}fail_dxevd{{.+}}
+// CHECK-NEXT: entry:
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}}cmpxchg ptr {{.+}} monotonic monotonic{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} acquire monotonic{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} release monotonic{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} acq_rel monotonic{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}}cmpxchg ptr {{.+}} seq_cst monotonic{{.+}}
+// CHECK: {{.+}}__kmpc_flush{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} monotonic acquire{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} acquire acquire{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} release acquire{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} acq_rel acquire{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} seq_cst acquire{{.+}}
+// CHECK: {{.+}}__kmpc_flush{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} monotonic seq_cst{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} acquire seq_cst{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} release seq_cst{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} acq_rel seq_cst{{.+}}
+// CHECK: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK-NEXT: {{.+}} bitcast double{{.+}}
+// CHECK: {{.+}}cmpxchg ptr {{.+}} seq_cst seq_cst{{.+}}
+// CHECK: call void {{.+}}__kmpc_flush{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} atomicrmw fmax {{.+}} seq_cst{{.+}}
+// CHECK-NEXT: call void {{.+}}__kmpc_flush{{.+}}
+// CHECK-NEXT: {{.+}} load double,{{.+}}
+// CHECK-NEXT: {{.+}} atomicrmw fmin {{.+}} monotonic{{.+}}
+// CHECK: ret double {{.+}}
diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h b/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
index abbef03d02cb10..669104307fa0e2 100644
--- a/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
+++ b/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
@@ -2562,6 +2562,13 @@ class OpenMPIRBuilder {
AtomicOpValue &V, AtomicOpValue &R, Value *E, Value *D,
AtomicOrdering AO, omp::OMPAtomicCompareOp Op,
bool IsXBinopExpr, bool IsPostfixUpdate, bool IsFailOnly);
+ InsertPointTy createAtomicCompare(const LocationDescription &Loc,
+ AtomicOpValue &X, AtomicOpValue &V,
+ AtomicOpValue &R, Value *E, Value *D,
+ AtomicOrdering AO,
+ omp::OMPAtomicCompareOp Op,
+ bool IsXBinopExpr, bool IsPostfixUpdate,
+ bool IsFailOnly, AtomicOrdering Failure);
/// Create the control flow structure of a canonical OpenMP loop.
///
diff --git a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
index ce428f78dc843e..f6cf358119fb71 100644
--- a/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
+++ b/llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
@@ -6026,6 +6026,17 @@ OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createAtomicCompare(
omp::OMPAtomicCompareOp Op, bool IsXBinopExpr, bool IsPostfixUpdate,
bool IsFailOnly) {
+ AtomicOrdering Failure = AtomicCmpXchgInst::getStrongestFailureOrdering(AO);
+ return createAtomicCompare(Loc, X, V, R, E, D, AO, Op, IsXBinopExpr,
+ IsPostfixUpdate, IsFailOnly, Failure);
+}
+
+OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createAtomicCompare(
+ const LocationDescription &Loc, AtomicOpValue &X, AtomicOpValue &V,
+ AtomicOpValue &R, Value *E, Value *D, AtomicOrdering AO,
+ omp::OMPAtomicCompareOp Op, bool IsXBinopExpr, bool IsPostfixUpdate,
+ bool IsFailOnly, AtomicOrdering Failure) {
+
if (!updateToLocation(Loc))
return Loc.IP;
@@ -6040,7 +6051,6 @@ OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createAtomicCompare(
bool IsInteger = E->getType()->isIntegerTy();
if (Op == OMPAtomicCompareOp::EQ) {
- AtomicOrdering Failure = AtomicCmpXchgInst::getStrongestFailureOrdering(AO);
AtomicCmpXchgInst *Result = nullptr;
if (!IsInteger) {
IntegerType *IntCastTy =
>From 44dbdb00ad93a7859872cca41d8a9021a402c799 Mon Sep 17 00:00:00 2001
From: Sunil Kuravinakop <kuravina at pe28vega.us.cray.com>
Date: Wed, 20 Dec 2023 11:25:06 -0600
Subject: [PATCH 3/3] Changes in name format from Alexey. Changed the
variable names of "fail" clause and the parameter to this fail clause more
self-explanatory.
---
clang/lib/CodeGen/CGStmtOpenMP.cpp | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp
index 225f13cb8c8869..e362c9da51fe31 100644
--- a/clang/lib/CodeGen/CGStmtOpenMP.cpp
+++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp
@@ -6579,14 +6579,14 @@ void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
if (KindsEncountered.contains(OMPC_compare) &&
KindsEncountered.contains(OMPC_fail)) {
Kind = OMPC_compare;
- const OMPFailClause *fC = S.getSingleClause<OMPFailClause>();
- if (fC) {
- OpenMPClauseKind fP = fC->getFailParameter();
- if (fP == llvm::omp::OMPC_relaxed)
+ const auto *FailClause = S.getSingleClause<OMPFailClause>();
+ if (FailClause) {
+ OpenMPClauseKind FailParameter = FailClause->getFailParameter();
+ if (FailParameter == llvm::omp::OMPC_relaxed)
FailAO = llvm::AtomicOrdering::Monotonic;
- else if (fP == llvm::omp::OMPC_acquire)
+ else if (FailParameter == llvm::omp::OMPC_acquire)
FailAO = llvm::AtomicOrdering::Acquire;
- else if (fP == llvm::omp::OMPC_seq_cst)
+ else if (FailParameter == llvm::omp::OMPC_seq_cst)
FailAO = llvm::AtomicOrdering::SequentiallyConsistent;
}
}
More information about the libcxx-commits
mailing list