NFC: make AtomicOrdering an enum class
Summary:
In the context of http://wg21.link/lwg2445 C++ uses the concept of
'stronger' ordering but doesn't define it properly. This should be fixed
in C++17 barring a small question that's still open.
The code currently plays fast and loose with the AtomicOrdering
enum. Using an enum class is one step towards tightening things. I later
also want to tighten related enums, such as clang's
AtomicOrderingKind (which should be shared with LLVM as a 'C++ ABI'
enum).
This change touches a few lines of code which can be improved later, I'd
like to keep it as NFC for now as it's already quite complex. I have
related changes for clang.
As a follow-up I'll add:
bool operator<(AtomicOrdering, AtomicOrdering) = delete;
bool operator>(AtomicOrdering, AtomicOrdering) = delete;
bool operator<=(AtomicOrdering, AtomicOrdering) = delete;
bool operator>=(AtomicOrdering, AtomicOrdering) = delete;
This is separate so that clang and LLVM changes don't need to be in sync.
Reviewers: jyknight, reames
Subscribers: jyknight, llvm-commits
Differential Revision: http://reviews.llvm.org/D18775
llvm-svn: 265602
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index c854320..bf1d2f00 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -1810,12 +1810,16 @@
bool LLParser::ParseOrdering(AtomicOrdering &Ordering) {
switch (Lex.getKind()) {
default: return TokError("Expected ordering on atomic instruction");
- case lltok::kw_unordered: Ordering = Unordered; break;
- case lltok::kw_monotonic: Ordering = Monotonic; break;
- case lltok::kw_acquire: Ordering = Acquire; break;
- case lltok::kw_release: Ordering = Release; break;
- case lltok::kw_acq_rel: Ordering = AcquireRelease; break;
- case lltok::kw_seq_cst: Ordering = SequentiallyConsistent; break;
+ case lltok::kw_unordered: Ordering = AtomicOrdering::Unordered; break;
+ case lltok::kw_monotonic: Ordering = AtomicOrdering::Monotonic; break;
+ // Not specified yet:
+ // case lltok::kw_consume: Ordering = AtomicOrdering::Consume; break;
+ case lltok::kw_acquire: Ordering = AtomicOrdering::Acquire; break;
+ case lltok::kw_release: Ordering = AtomicOrdering::Release; break;
+ case lltok::kw_acq_rel: Ordering = AtomicOrdering::AcquireRelease; break;
+ case lltok::kw_seq_cst:
+ Ordering = AtomicOrdering::SequentiallyConsistent;
+ break;
}
Lex.Lex();
return false;
@@ -5884,7 +5888,7 @@
unsigned Alignment = 0;
bool AteExtraComma = false;
bool isAtomic = false;
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
if (Lex.getKind() == lltok::kw_atomic) {
@@ -5911,7 +5915,8 @@
return Error(Loc, "load operand must be a pointer to a first class type");
if (isAtomic && !Alignment)
return Error(Loc, "atomic load must have explicit non-zero alignment");
- if (Ordering == Release || Ordering == AcquireRelease)
+ if (Ordering == AtomicOrdering::Release ||
+ Ordering == AtomicOrdering::AcquireRelease)
return Error(Loc, "atomic load cannot use Release ordering");
if (Ty != cast<PointerType>(Val->getType())->getElementType())
@@ -5932,7 +5937,7 @@
unsigned Alignment = 0;
bool AteExtraComma = false;
bool isAtomic = false;
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
if (Lex.getKind() == lltok::kw_atomic) {
@@ -5961,7 +5966,8 @@
return Error(Loc, "stored value and pointer type do not match");
if (isAtomic && !Alignment)
return Error(Loc, "atomic store must have explicit non-zero alignment");
- if (Ordering == Acquire || Ordering == AcquireRelease)
+ if (Ordering == AtomicOrdering::Acquire ||
+ Ordering == AtomicOrdering::AcquireRelease)
return Error(Loc, "atomic store cannot use Acquire ordering");
Inst = new StoreInst(Val, Ptr, isVolatile, Alignment, Ordering, Scope);
@@ -5974,8 +5980,8 @@
int LLParser::ParseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc;
bool AteExtraComma = false;
- AtomicOrdering SuccessOrdering = NotAtomic;
- AtomicOrdering FailureOrdering = NotAtomic;
+ AtomicOrdering SuccessOrdering = AtomicOrdering::NotAtomic;
+ AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
bool isVolatile = false;
bool isWeak = false;
@@ -5995,12 +6001,16 @@
ParseOrdering(FailureOrdering))
return true;
- if (SuccessOrdering == Unordered || FailureOrdering == Unordered)
+ if (SuccessOrdering == AtomicOrdering::Unordered ||
+ FailureOrdering == AtomicOrdering::Unordered)
return TokError("cmpxchg cannot be unordered");
- if (SuccessOrdering < FailureOrdering)
- return TokError("cmpxchg must be at least as ordered on success as failure");
- if (FailureOrdering == Release || FailureOrdering == AcquireRelease)
- return TokError("cmpxchg failure ordering cannot include release semantics");
+ if (isStrongerThan(FailureOrdering, SuccessOrdering))
+ return TokError("cmpxchg failure argument shall be no stronger than the "
+ "success argument");
+ if (FailureOrdering == AtomicOrdering::Release ||
+ FailureOrdering == AtomicOrdering::AcquireRelease)
+ return TokError(
+ "cmpxchg failure ordering cannot include release semantics");
if (!Ptr->getType()->isPointerTy())
return Error(PtrLoc, "cmpxchg operand must be a pointer");
if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
@@ -6023,7 +6033,7 @@
int LLParser::ParseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
Value *Ptr, *Val; LocTy PtrLoc, ValLoc;
bool AteExtraComma = false;
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
bool isVolatile = false;
AtomicRMWInst::BinOp Operation;
@@ -6053,7 +6063,7 @@
ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
return true;
- if (Ordering == Unordered)
+ if (Ordering == AtomicOrdering::Unordered)
return TokError("atomicrmw cannot be unordered");
if (!Ptr->getType()->isPointerTy())
return Error(PtrLoc, "atomicrmw operand must be a pointer");
@@ -6076,14 +6086,14 @@
/// ParseFence
/// ::= 'fence' 'singlethread'? AtomicOrdering
int LLParser::ParseFence(Instruction *&Inst, PerFunctionState &PFS) {
- AtomicOrdering Ordering = NotAtomic;
+ AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
SynchronizationScope Scope = CrossThread;
if (ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
return true;
- if (Ordering == Unordered)
+ if (Ordering == AtomicOrdering::Unordered)
return TokError("fence cannot be unordered");
- if (Ordering == Monotonic)
+ if (Ordering == AtomicOrdering::Monotonic)
return TokError("fence cannot be monotonic");
Inst = new FenceInst(Context, Ordering, Scope);