Skip to content
This repository was archived by the owner on Nov 1, 2021. It is now read-only.

Commit a84ed32

Browse files
jfbastienjfbastien
committed
NFC: make AtomicOrdering an enum class
Summary: See LLVM change D18775 for details, this change depends on it. Reviewers: jyknight, reames Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D18776 git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@265569 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent 017686a commit a84ed32

8 files changed

+125
-114
lines changed

Diff for: ‎lib/CodeGen/CGAtomic.cpp

+46-39
Original file line numberDiff line numberDiff line change
@@ -221,11 +221,13 @@ namespace {
221221
/// \param IsWeak true if atomic operation is weak, false otherwise.
222222
/// \returns Pair of values: previous value from storage (value type) and
223223
/// boolean flag (i1 type) with true if success and false otherwise.
224-
std::pair<RValue, llvm::Value *> EmitAtomicCompareExchange(
225-
RValue Expected, RValue Desired,
226-
llvm::AtomicOrdering Success = llvm::SequentiallyConsistent,
227-
llvm::AtomicOrdering Failure = llvm::SequentiallyConsistent,
228-
bool IsWeak = false);
224+
std::pair<RValue, llvm::Value *>
225+
EmitAtomicCompareExchange(RValue Expected, RValue Desired,
226+
llvm::AtomicOrdering Success =
227+
llvm::AtomicOrdering::SequentiallyConsistent,
228+
llvm::AtomicOrdering Failure =
229+
llvm::AtomicOrdering::SequentiallyConsistent,
230+
bool IsWeak = false);
229231

230232
/// \brief Emits atomic update.
231233
/// \param AO Atomic ordering.
@@ -260,13 +262,17 @@ namespace {
260262
/// \brief Emits atomic compare-and-exchange op as a libcall.
261263
llvm::Value *EmitAtomicCompareExchangeLibcall(
262264
llvm::Value *ExpectedAddr, llvm::Value *DesiredAddr,
263-
llvm::AtomicOrdering Success = llvm::SequentiallyConsistent,
264-
llvm::AtomicOrdering Failure = llvm::SequentiallyConsistent);
265+
llvm::AtomicOrdering Success =
266+
llvm::AtomicOrdering::SequentiallyConsistent,
267+
llvm::AtomicOrdering Failure =
268+
llvm::AtomicOrdering::SequentiallyConsistent);
265269
/// \brief Emits atomic compare-and-exchange op as LLVM instruction.
266270
std::pair<llvm::Value *, llvm::Value *> EmitAtomicCompareExchangeOp(
267271
llvm::Value *ExpectedVal, llvm::Value *DesiredVal,
268-
llvm::AtomicOrdering Success = llvm::SequentiallyConsistent,
269-
llvm::AtomicOrdering Failure = llvm::SequentiallyConsistent,
272+
llvm::AtomicOrdering Success =
273+
llvm::AtomicOrdering::SequentiallyConsistent,
274+
llvm::AtomicOrdering Failure =
275+
llvm::AtomicOrdering::SequentiallyConsistent,
270276
bool IsWeak = false);
271277
/// \brief Emit atomic update as libcalls.
272278
void
@@ -289,17 +295,17 @@ namespace {
289295
AtomicExpr::AtomicOrderingKind
290296
AtomicInfo::translateAtomicOrdering(const llvm::AtomicOrdering AO) {
291297
switch (AO) {
292-
case llvm::Unordered:
293-
case llvm::NotAtomic:
294-
case llvm::Monotonic:
298+
case llvm::AtomicOrdering::Unordered:
299+
case llvm::AtomicOrdering::NotAtomic:
300+
case llvm::AtomicOrdering::Monotonic:
295301
return AtomicExpr::AO_ABI_memory_order_relaxed;
296-
case llvm::Acquire:
302+
case llvm::AtomicOrdering::Acquire:
297303
return AtomicExpr::AO_ABI_memory_order_acquire;
298-
case llvm::Release:
304+
case llvm::AtomicOrdering::Release:
299305
return AtomicExpr::AO_ABI_memory_order_release;
300-
case llvm::AcquireRelease:
306+
case llvm::AtomicOrdering::AcquireRelease:
301307
return AtomicExpr::AO_ABI_memory_order_acq_rel;
302-
case llvm::SequentiallyConsistent:
308+
case llvm::AtomicOrdering::SequentiallyConsistent:
303309
return AtomicExpr::AO_ABI_memory_order_seq_cst;
304310
}
305311
llvm_unreachable("Unhandled AtomicOrdering");
@@ -431,14 +437,14 @@ static void emitAtomicCmpXchgFailureSet(CodeGenFunction &CGF, AtomicExpr *E,
431437
if (llvm::ConstantInt *FO = dyn_cast<llvm::ConstantInt>(FailureOrderVal)) {
432438
switch (FO->getSExtValue()) {
433439
default:
434-
FailureOrder = llvm::Monotonic;
440+
FailureOrder = llvm::AtomicOrdering::Monotonic;
435441
break;
436442
case AtomicExpr::AO_ABI_memory_order_consume:
437443
case AtomicExpr::AO_ABI_memory_order_acquire:
438-
FailureOrder = llvm::Acquire;
444+
FailureOrder = llvm::AtomicOrdering::Acquire;
439445
break;
440446
case AtomicExpr::AO_ABI_memory_order_seq_cst:
441-
FailureOrder = llvm::SequentiallyConsistent;
447+
FailureOrder = llvm::AtomicOrdering::SequentiallyConsistent;
442448
break;
443449
}
444450
if (FailureOrder >= SuccessOrder) {
@@ -455,9 +461,10 @@ static void emitAtomicCmpXchgFailureSet(CodeGenFunction &CGF, AtomicExpr *E,
455461
llvm::BasicBlock *MonotonicBB = nullptr, *AcquireBB = nullptr,
456462
*SeqCstBB = nullptr;
457463
MonotonicBB = CGF.createBasicBlock("monotonic_fail", CGF.CurFn);
458-
if (SuccessOrder != llvm::Monotonic && SuccessOrder != llvm::Release)
464+
if (SuccessOrder != llvm::AtomicOrdering::Monotonic &&
465+
SuccessOrder != llvm::AtomicOrdering::Release)
459466
AcquireBB = CGF.createBasicBlock("acquire_fail", CGF.CurFn);
460-
if (SuccessOrder == llvm::SequentiallyConsistent)
467+
if (SuccessOrder == llvm::AtomicOrdering::SequentiallyConsistent)
461468
SeqCstBB = CGF.createBasicBlock("seqcst_fail", CGF.CurFn);
462469

463470
llvm::BasicBlock *ContBB = CGF.createBasicBlock("atomic.continue", CGF.CurFn);
@@ -471,13 +478,13 @@ static void emitAtomicCmpXchgFailureSet(CodeGenFunction &CGF, AtomicExpr *E,
471478
// doesn't fold to a constant for the ordering.
472479
CGF.Builder.SetInsertPoint(MonotonicBB);
473480
emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
474-
Size, SuccessOrder, llvm::Monotonic);
481+
Size, SuccessOrder, llvm::AtomicOrdering::Monotonic);
475482
CGF.Builder.CreateBr(ContBB);
476483

477484
if (AcquireBB) {
478485
CGF.Builder.SetInsertPoint(AcquireBB);
479486
emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
480-
Size, SuccessOrder, llvm::Acquire);
487+
Size, SuccessOrder, llvm::AtomicOrdering::Acquire);
481488
CGF.Builder.CreateBr(ContBB);
482489
SI->addCase(CGF.Builder.getInt32(AtomicExpr::AO_ABI_memory_order_consume),
483490
AcquireBB);
@@ -486,8 +493,8 @@ static void emitAtomicCmpXchgFailureSet(CodeGenFunction &CGF, AtomicExpr *E,
486493
}
487494
if (SeqCstBB) {
488495
CGF.Builder.SetInsertPoint(SeqCstBB);
489-
emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
490-
Size, SuccessOrder, llvm::SequentiallyConsistent);
496+
emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2, Size, SuccessOrder,
497+
llvm::AtomicOrdering::SequentiallyConsistent);
491498
CGF.Builder.CreateBr(ContBB);
492499
SI->addCase(CGF.Builder.getInt32(AtomicExpr::AO_ABI_memory_order_seq_cst),
493500
SeqCstBB);
@@ -1040,30 +1047,30 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
10401047
switch (ord) {
10411048
case AtomicExpr::AO_ABI_memory_order_relaxed:
10421049
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1043-
Size, llvm::Monotonic);
1050+
Size, llvm::AtomicOrdering::Monotonic);
10441051
break;
10451052
case AtomicExpr::AO_ABI_memory_order_consume:
10461053
case AtomicExpr::AO_ABI_memory_order_acquire:
10471054
if (IsStore)
10481055
break; // Avoid crashing on code with undefined behavior
10491056
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1050-
Size, llvm::Acquire);
1057+
Size, llvm::AtomicOrdering::Acquire);
10511058
break;
10521059
case AtomicExpr::AO_ABI_memory_order_release:
10531060
if (IsLoad)
10541061
break; // Avoid crashing on code with undefined behavior
10551062
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1056-
Size, llvm::Release);
1063+
Size, llvm::AtomicOrdering::Release);
10571064
break;
10581065
case AtomicExpr::AO_ABI_memory_order_acq_rel:
10591066
if (IsLoad || IsStore)
10601067
break; // Avoid crashing on code with undefined behavior
10611068
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1062-
Size, llvm::AcquireRelease);
1069+
Size, llvm::AtomicOrdering::AcquireRelease);
10631070
break;
10641071
case AtomicExpr::AO_ABI_memory_order_seq_cst:
10651072
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1066-
Size, llvm::SequentiallyConsistent);
1073+
Size, llvm::AtomicOrdering::SequentiallyConsistent);
10671074
break;
10681075
default: // invalid order
10691076
// We should not ever get here normally, but it's hard to
@@ -1104,12 +1111,12 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
11041111
// Emit all the different atomics
11051112
Builder.SetInsertPoint(MonotonicBB);
11061113
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1107-
Size, llvm::Monotonic);
1114+
Size, llvm::AtomicOrdering::Monotonic);
11081115
Builder.CreateBr(ContBB);
11091116
if (!IsStore) {
11101117
Builder.SetInsertPoint(AcquireBB);
11111118
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1112-
Size, llvm::Acquire);
1119+
Size, llvm::AtomicOrdering::Acquire);
11131120
Builder.CreateBr(ContBB);
11141121
SI->addCase(Builder.getInt32(AtomicExpr::AO_ABI_memory_order_consume),
11151122
AcquireBB);
@@ -1119,22 +1126,22 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
11191126
if (!IsLoad) {
11201127
Builder.SetInsertPoint(ReleaseBB);
11211128
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1122-
Size, llvm::Release);
1129+
Size, llvm::AtomicOrdering::Release);
11231130
Builder.CreateBr(ContBB);
11241131
SI->addCase(Builder.getInt32(AtomicExpr::AO_ABI_memory_order_release),
11251132
ReleaseBB);
11261133
}
11271134
if (!IsLoad && !IsStore) {
11281135
Builder.SetInsertPoint(AcqRelBB);
11291136
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1130-
Size, llvm::AcquireRelease);
1137+
Size, llvm::AtomicOrdering::AcquireRelease);
11311138
Builder.CreateBr(ContBB);
11321139
SI->addCase(Builder.getInt32(AtomicExpr::AO_ABI_memory_order_acq_rel),
11331140
AcqRelBB);
11341141
}
11351142
Builder.SetInsertPoint(SeqCstBB);
11361143
EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, IsWeak, OrderFail,
1137-
Size, llvm::SequentiallyConsistent);
1144+
Size, llvm::AtomicOrdering::SequentiallyConsistent);
11381145
Builder.CreateBr(ContBB);
11391146
SI->addCase(Builder.getInt32(AtomicExpr::AO_ABI_memory_order_seq_cst),
11401147
SeqCstBB);
@@ -1318,9 +1325,9 @@ RValue CodeGenFunction::EmitAtomicLoad(LValue LV, SourceLocation SL,
13181325
llvm::AtomicOrdering AO;
13191326
bool IsVolatile = LV.isVolatileQualified();
13201327
if (LV.getType()->isAtomicType()) {
1321-
AO = llvm::SequentiallyConsistent;
1328+
AO = llvm::AtomicOrdering::SequentiallyConsistent;
13221329
} else {
1323-
AO = llvm::Acquire;
1330+
AO = llvm::AtomicOrdering::Acquire;
13241331
IsVolatile = true;
13251332
}
13261333
return EmitAtomicLoad(LV, SL, AO, IsVolatile, Slot);
@@ -1739,9 +1746,9 @@ void CodeGenFunction::EmitAtomicStore(RValue rvalue, LValue lvalue,
17391746
bool IsVolatile = lvalue.isVolatileQualified();
17401747
llvm::AtomicOrdering AO;
17411748
if (lvalue.getType()->isAtomicType()) {
1742-
AO = llvm::SequentiallyConsistent;
1749+
AO = llvm::AtomicOrdering::SequentiallyConsistent;
17431750
} else {
1744-
AO = llvm::Release;
1751+
AO = llvm::AtomicOrdering::Release;
17451752
IsVolatile = true;
17461753
}
17471754
return EmitAtomicStore(rvalue, lvalue, AO, IsVolatile, isInit);

0 commit comments

Comments
 (0)