[CGAtomic] Lyft strong requirement for remaining compare_exchange combinations

[bruno]

Summary

Follow up on 431e3138a and complete the other possible combinations.

Besides enforcing the new behavior it also mitigates several TSAN false positives
when combining orders that used to be stronger and therefore not allowed.

[bruno]

Fix failing tests and clang-format issue.

[rjmccall]

Your change is correct, but I think there's a deeper flaw in this code.

clang/lib/CodeGen/CGAtomic.cpp

460

Is this logic correct post-C++17? It looks like if you request a relaxed success order and an acquire failure order, this will use a relaxed order for both. That used to be okay because of the no-stronger restriction, but I think it's just invalid now, and all the conditionality needs to be removed.

[jfb]

clang/lib/CodeGen/CGAtomic.cpp

460

Hmm, I kinda feel like the whole switch thing is silly and we might want to just seq_cst any non-constexpr values. Barring that, yeah we should just adopt the C++17 change unconditionally, since the previous behavior was kinda silly.

[bruno]

clang/lib/CodeGen/CGAtomic.cpp

460

@rjmccall You are right about relaxed/acquire, I plan to address that in the future, I noticed this exact problem this morning while trying to fix D99434.

@jfb why is it silly? Isn't it possible to use runtime values that are still legit and would benefit from the switch? Or did you just mean for the specific case in John's comment?

[rjmccall]

Don't mind JF, he's just forgotten that C++ lacks the ability to turn the typically constant value arguments passed to functions like std::atomic::compare_exchange_strong into actual compile-time constants to the builtin used within those functions, so his advice would mean emitting all atomics in C++ as sequentially consistent.

Bruno, I think it would be straightforward to just fix this now; you just need to make creating AcquireBB and SeqCstBB unconditional. If you think there's a good reason not to do that in one patch, I won't insist, but it feels to me like the right patch.

[jfb]

In D101501#2735352, @rjmccall wrote:

Don't mind JF, he's just forgotten that C++ lacks the ability to turn the typically constant value arguments passed to functions like std::atomic::compare_exchange_strong into actual compile-time constants to the builtin used within those functions, so his advice would mean emitting all atomics in C++ as sequentially consistent.

Ugh right you are ☹️
I have a small soapbox about making this stuff a template parameter but I'll keep it to myself.

[bruno]

Don't mind JF, he's just forgotten that C++ lacks the ability to turn the typically constant value arguments passed to functions like std::atomic::compare_exchange_strong into actual compile-time constants to the builtin used within those functions, so his advice would mean emitting all atomics in C++ as sequentially consistent.

C++ often pushing towards the harsh reality!

Bruno, I think it would be straightforward to just fix this now; you just need to make creating AcquireBB and SeqCstBB unconditional. If you think there's a good reason not to do that in one patch, I won't insist, but it feels to me like the right patch.

Fair enough, will do! Thanks for bringing it up.

I have a small soapbox about making this stuff a template parameter but I'll keep it to myself.

Why not a small paper? :D

[rjmccall]

In D101501#2737180, @jfb wrote:

In D101501#2735352, @rjmccall wrote:

Don't mind JF, he's just forgotten that C++ lacks the ability to turn the typically constant value arguments passed to functions like std::atomic::compare_exchange_strong into actual compile-time constants to the builtin used within those functions, so his advice would mean emitting all atomics in C++ as sequentially consistent.

Ugh right you are ☹️
I have a small soapbox about making this stuff a template parameter but I'll keep it to myself.

It's almost funny how much IR this generates at -O0 (and a fix here will make it worse, of course). I wish it worked any other way. :)

[bruno]

Update after @rjmccall comments!

[bruno]

Reduce the diff in a test.

[rjmccall]

LGTM, except that the commit message should say "Lift", not "Lyft". ;)

[bruno]

LGTM, except that the commit message should say "Lift", not "Lyft". ;)

LOL, thanks!

[bruno]

Forgot to add the Differential tag, my bad. Closed by https://reviews.llvm.org/rG819e0d105e84

clang/lib/CodeGen/CGAtomic.cpp

if (llvm::ConstantInt *FO = dyn_cast<llvm::ConstantInt>(FailureOrderVal)) {
     // precondition is 31.7.2.18. Effectively treat this as a DR and skip
     // language version checks.
     emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2, Size, SuccessOrder,
                       FailureOrder, Scope);
     return;
   }
 
   // Create all the relevant BB's
-  llvm::BasicBlock *MonotonicBB = nullptr, *AcquireBB = nullptr,
-                   *SeqCstBB = nullptr;
-  MonotonicBB = CGF.createBasicBlock("monotonic_fail", CGF.CurFn);
-  if (SuccessOrder != llvm::AtomicOrdering::Monotonic)
-    AcquireBB = CGF.createBasicBlock("acquire_fail", CGF.CurFn);
-  if (SuccessOrder == llvm::AtomicOrdering::SequentiallyConsistent)
-    SeqCstBB = CGF.createBasicBlock("seqcst_fail", CGF.CurFn);
-
-  llvm::BasicBlock *ContBB = CGF.createBasicBlock("atomic.continue", CGF.CurFn);
-
-  llvm::SwitchInst *SI = CGF.Builder.CreateSwitch(FailureOrderVal, MonotonicBB);
-
-  // Emit all the different atomics
+  auto *MonotonicBB = CGF.createBasicBlock("monotonic_fail", CGF.CurFn);
+  auto *AcquireBB = CGF.createBasicBlock("acquire_fail", CGF.CurFn);
+  auto *SeqCstBB = CGF.createBasicBlock("seqcst_fail", CGF.CurFn);
+  auto *ContBB = CGF.createBasicBlock("atomic.continue", CGF.CurFn);
 
   // MonotonicBB is arbitrarily chosen as the default case; in practice, this
   // doesn't matter unless someone is crazy enough to use something that
   // doesn't fold to a constant for the ordering.
+  llvm::SwitchInst *SI = CGF.Builder.CreateSwitch(FailureOrderVal, MonotonicBB);
+  // Implemented as acquire, since it's the closest in LLVM.
+  SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::consume),
+              AcquireBB);
+  SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::acquire),
+              AcquireBB);
+  SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::seq_cst),
+              SeqCstBB);
+
+  // Emit all the different atomics
   CGF.Builder.SetInsertPoint(MonotonicBB);
   emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
                     Size, SuccessOrder, llvm::AtomicOrdering::Monotonic, Scope);
   CGF.Builder.CreateBr(ContBB);
 
-  if (AcquireBB) {
-    CGF.Builder.SetInsertPoint(AcquireBB);
-    emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2,
-                      Size, SuccessOrder, llvm::AtomicOrdering::Acquire, Scope);
-    CGF.Builder.CreateBr(ContBB);
-    if (SuccessOrder != llvm::AtomicOrdering::Release)
-      SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::consume),
-                  AcquireBB);
-    SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::acquire),
-                AcquireBB);
-  }
-  if (SeqCstBB) {
-    CGF.Builder.SetInsertPoint(SeqCstBB);
-    emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2, Size, SuccessOrder,
-                      llvm::AtomicOrdering::SequentiallyConsistent, Scope);
-    CGF.Builder.CreateBr(ContBB);
-    SI->addCase(CGF.Builder.getInt32((int)llvm::AtomicOrderingCABI::seq_cst),
-                SeqCstBB);
-  }
+  emitAtomicCmpXchg(CGF, E, IsWeak, Dest, Ptr, Val1, Val2, Size, SuccessOrder,
+                    llvm::AtomicOrdering::Acquire, Scope);
+
 
   CGF.Builder.SetInsertPoint(ContBB);
 }
 
 /// Duplicate the atomic min/max operation in conventional IR for the builtin
 /// variants that return the new rather than the original value.
 static llvm::Value *EmitPostAtomicMinMax(CGBuilderTy &Builder,
                                          AtomicExpr::AtomicOp Op,

clang/test/CodeGen/atomic-ops.c

void generalFailureOrder(_Atomic(int) *ptr, int *ptr2, int success, int fail) {
   // CHECK-NEXT: i32 1, label %[[ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[ACQUIRE]]
   // CHECK-NEXT: i32 3, label %[[RELEASE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 4, label %[[ACQREL:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 5, label %[[SEQCST:[0-9a-zA-Z._]+]]
 
   // CHECK: [[MONOTONIC]]
   // CHECK: switch {{.*}}, label %[[MONOTONIC_MONOTONIC:[0-9a-zA-Z._]+]] [
+  // CHECK-NEXT: i32 1, label %[[MONOTONIC_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 2, label %[[MONOTONIC_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[MONOTONIC_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[ACQUIRE]]
   // CHECK: switch {{.*}}, label %[[ACQUIRE_MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[ACQUIRE_ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[ACQUIRE_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[ACQUIRE_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[RELEASE]]
   // CHECK: switch {{.*}}, label %[[RELEASE_MONOTONIC:[0-9a-zA-Z._]+]] [
+  // CHECK-NEXT: i32 1, label %[[RELEASE_ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[RELEASE_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[RELEASE_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[ACQREL]]
   // CHECK: switch {{.*}}, label %[[ACQREL_MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[ACQREL_ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[ACQREL_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[ACQREL_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[SEQCST]]
   // CHECK: switch {{.*}}, label %[[SEQCST_MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[SEQCST_ACQUIRE:[0-9a-zA-Z._]+]]
-  // CHECK-NEXT: i32 2, label %[[SEQCST_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 2, label %[[SEQCST_ACQUIRE]]
   // CHECK-NEXT: i32 5, label %[[SEQCST_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[MONOTONIC_MONOTONIC]]
   // CHECK: cmpxchg {{.*}} monotonic monotonic, align
   // CHECK: br
 
+  // CHECK: [[MONOTONIC_ACQUIRE]]
+  // CHECK: cmpxchg {{.*}} monotonic acquire, align
+  // CHECK: br
+
+  // CHECK: [[MONOTONIC_SEQCST]]
+  // CHECK: cmpxchg {{.*}} monotonic seq_cst, align
+  // CHECK: br
+
   // CHECK: [[ACQUIRE_MONOTONIC]]
   // CHECK: cmpxchg {{.*}} acquire monotonic, align
   // CHECK: br
 
   // CHECK: [[ACQUIRE_ACQUIRE]]
   // CHECK: cmpxchg {{.*}} acquire acquire, align
   // CHECK: br
 
+  // CHECK: [[ACQUIRE_SEQCST]]
+  // CHECK: cmpxchg {{.*}} acquire seq_cst, align
+  // CHECK: br
+
   // CHECK: [[RELEASE_MONOTONIC]]
   // CHECK: cmpxchg {{.*}} release monotonic, align
   // CHECK: br
 
   // CHECK: [[RELEASE_ACQUIRE]]
   // CHECK: cmpxchg {{.*}} release acquire, align
   // CHECK: br
 
+  // CHECK: [[RELEASE_SEQCST]]
+  // CHECK: cmpxchg {{.*}} release seq_cst, align
+  // CHECK: br
+
   // CHECK: [[ACQREL_MONOTONIC]]
   // CHECK: cmpxchg {{.*}} acq_rel monotonic, align
   // CHECK: br
 
   // CHECK: [[ACQREL_ACQUIRE]]
   // CHECK: cmpxchg {{.*}} acq_rel acquire, align
   // CHECK: br
 
+  // CHECK: [[ACQREL_SEQCST]]
+  // CHECK: cmpxchg {{.*}} acq_rel seq_cst, align
+  // CHECK: br
+
   // CHECK: [[SEQCST_MONOTONIC]]
   // CHECK: cmpxchg {{.*}} seq_cst monotonic, align
   // CHECK: br
 
   // CHECK: [[SEQCST_ACQUIRE]]
   // CHECK: cmpxchg {{.*}} seq_cst acquire, align
   // CHECK: br
 

 }
 
 // Having checked the flow in the previous two cases, we'll trust clang to
 // combine them sanely.
 void EMIT_ALL_THE_THINGS(int *ptr, int *ptr2, int new, _Bool weak, int success, int fail) {
   __atomic_compare_exchange(ptr, ptr2, &new, weak, success, fail);
 
   // CHECK: = cmpxchg {{.*}} monotonic monotonic, align
+  // CHECK: = cmpxchg {{.*}} monotonic acquire, align
+  // CHECK: = cmpxchg {{.*}} monotonic seq_cst, align
   // CHECK: = cmpxchg weak {{.*}} monotonic monotonic, align
+  // CHECK: = cmpxchg weak {{.*}} monotonic acquire, align
+  // CHECK: = cmpxchg weak {{.*}} monotonic seq_cst, align
   // CHECK: = cmpxchg {{.*}} acquire monotonic, align
   // CHECK: = cmpxchg {{.*}} acquire acquire, align
+  // CHECK: = cmpxchg {{.*}} acquire seq_cst, align
   // CHECK: = cmpxchg weak {{.*}} acquire monotonic, align
   // CHECK: = cmpxchg weak {{.*}} acquire acquire, align
+  // CHECK: = cmpxchg weak {{.*}} acquire seq_cst, align
   // CHECK: = cmpxchg {{.*}} release monotonic, align
   // CHECK: = cmpxchg {{.*}} release acquire, align
+  // CHECK: = cmpxchg {{.*}} release seq_cst, align
   // CHECK: = cmpxchg weak {{.*}} release monotonic, align
   // CHECK: = cmpxchg weak {{.*}} release acquire, align
+  // CHECK: = cmpxchg weak {{.*}} release seq_cst, align
   // CHECK: = cmpxchg {{.*}} acq_rel monotonic, align
   // CHECK: = cmpxchg {{.*}} acq_rel acquire, align
+  // CHECK: = cmpxchg {{.*}} acq_rel seq_cst, align
   // CHECK: = cmpxchg weak {{.*}} acq_rel monotonic, align
   // CHECK: = cmpxchg weak {{.*}} acq_rel acquire, align
+  // CHECK: = cmpxchg weak {{.*}} acq_rel seq_cst, align
   // CHECK: = cmpxchg {{.*}} seq_cst monotonic, align
   // CHECK: = cmpxchg {{.*}} seq_cst acquire, align
   // CHECK: = cmpxchg {{.*}} seq_cst seq_cst, align
   // CHECK: = cmpxchg weak {{.*}} seq_cst monotonic, align
   // CHECK: = cmpxchg weak {{.*}} seq_cst acquire, align
   // CHECK: = cmpxchg weak {{.*}} seq_cst seq_cst, align
 }
 

clang/test/CodeGenOpenCL/atomic-ops.cl

void failureOrder(atomic_int *ptr, int *ptr2) {
 
   // CHECK: cmpxchg weak i32* {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z._]+}}, i32 {{%[0-9A-Za-z_.]+}} syncscope("workgroup") seq_cst acquire, align 4
   __opencl_atomic_compare_exchange_weak(ptr, ptr2, 43, memory_order_seq_cst, memory_order_acquire, memory_scope_work_group);
 }
 
 // CHECK-LABEL: @generalFailureOrder
 void generalFailureOrder(atomic_int *ptr, int *ptr2, int success, int fail) {
   __opencl_atomic_compare_exchange_strong(ptr, ptr2, 42, success, fail, memory_scope_work_group);
-  // CHECK: switch i32 {{.*}}, label %[[MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[ACQUIRE]]
   // CHECK-NEXT: i32 3, label %[[RELEASE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 4, label %[[ACQREL:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 5, label %[[SEQCST:[0-9a-zA-Z._]+]]
 
   // CHECK: [[MONOTONIC]]
   // CHECK: switch {{.*}}, label %[[MONOTONIC_MONOTONIC:[0-9a-zA-Z._]+]] [
+  // CHECK-NEXT: i32 1, label %[[MONOTONIC_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 2, label %[[MONOTONIC_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[MONOTONIC_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[ACQUIRE]]
   // CHECK: switch {{.*}}, label %[[ACQUIRE_MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[ACQUIRE_ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[ACQUIRE_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[ACQUIRE_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[RELEASE]]
   // CHECK: switch {{.*}}, label %[[RELEASE_MONOTONIC:[0-9a-zA-Z._]+]] [
+  // CHECK-NEXT: i32 1, label %[[RELEASE_ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[RELEASE_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[RELEASE_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[ACQREL]]
   // CHECK: switch {{.*}}, label %[[ACQREL_MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[ACQREL_ACQUIRE:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: i32 2, label %[[ACQREL_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 5, label %[[ACQREL_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[SEQCST]]
   // CHECK: switch {{.*}}, label %[[SEQCST_MONOTONIC:[0-9a-zA-Z._]+]] [
   // CHECK-NEXT: i32 1, label %[[SEQCST_ACQUIRE:[0-9a-zA-Z._]+]]
-  // CHECK-NEXT: i32 2, label %[[SEQCST_ACQUIRE:[0-9a-zA-Z._]+]]
+  // CHECK-NEXT: i32 2, label %[[SEQCST_ACQUIRE]]
   // CHECK-NEXT: i32 5, label %[[SEQCST_SEQCST:[0-9a-zA-Z._]+]]
   // CHECK-NEXT: ]
 
   // CHECK: [[MONOTONIC_MONOTONIC]]
-  // CHECK: cmpxchg {{.*}} monotonic monotonic, align 4
+  // CHECK: cmpxchg {{.*}} monotonic monotonic, align
+  // CHECK: br
+
+  // CHECK: [[MONOTONIC_ACQUIRE]]
+  // CHECK: cmpxchg {{.*}} monotonic acquire, align
+  // CHECK: br
+
+  // CHECK: [[MONOTONIC_SEQCST]]
+  // CHECK: cmpxchg {{.*}} monotonic seq_cst, align
   // CHECK: br
 
   // CHECK: [[ACQUIRE_MONOTONIC]]
-  // CHECK: cmpxchg {{.*}} acquire monotonic, align 4
+  // CHECK: cmpxchg {{.*}} acquire monotonic, align
   // CHECK: br
 
   // CHECK: [[ACQUIRE_ACQUIRE]]
-  // CHECK: cmpxchg {{.*}} acquire acquire, align 4
+  // CHECK: cmpxchg {{.*}} acquire acquire, align
+  // CHECK: br
+
+  // CHECK: [[ACQUIRE_SEQCST]]
+  // CHECK: cmpxchg {{.*}} acquire seq_cst, align
   // CHECK: br
 
   // CHECK: [[RELEASE_MONOTONIC]]
-  // CHECK: cmpxchg {{.*}} release monotonic, align 4
+  // CHECK: cmpxchg {{.*}} release monotonic, align
   // CHECK: br
 
   // CHECK: [[RELEASE_ACQUIRE]]
-  // CHECK: cmpxchg {{.*}} release acquire, align 4
+  // CHECK: cmpxchg {{.*}} release acquire, align
+  // CHECK: br
+
+  // CHECK: [[RELEASE_SEQCST]]
+  // CHECK: cmpxchg {{.*}} release seq_cst, align
   // CHECK: br
 
   // CHECK: [[ACQREL_MONOTONIC]]
-  // CHECK: cmpxchg {{.*}} acq_rel monotonic, align 4
+  // CHECK: cmpxchg {{.*}} acq_rel monotonic, align
   // CHECK: br
 
   // CHECK: [[ACQREL_ACQUIRE]]
-  // CHECK: cmpxchg {{.*}} acq_rel acquire, align 4
+  // CHECK: cmpxchg {{.*}} acq_rel acquire, align
+  // CHECK: br
+
+  // CHECK: [[ACQREL_SEQCST]]
+  // CHECK: cmpxchg {{.*}} acq_rel seq_cst, align
   // CHECK: br
 
   // CHECK: [[SEQCST_MONOTONIC]]
-  // CHECK: cmpxchg {{.*}} seq_cst monotonic, align 4
+  // CHECK: cmpxchg {{.*}} seq_cst monotonic, align
   // CHECK: br
 
   // CHECK: [[SEQCST_ACQUIRE]]
-  // CHECK: cmpxchg {{.*}} seq_cst acquire, align 4
+  // CHECK: cmpxchg {{.*}} seq_cst acquire, align
   // CHECK: br
 
   // CHECK: [[SEQCST_SEQCST]]
-  // CHECK: cmpxchg {{.*}} seq_cst seq_cst, align 4
+  // CHECK: cmpxchg {{.*}} seq_cst seq_cst, align
   // CHECK: br
 }
 
 int test_volatile(volatile atomic_int *i) {
   // CHECK-LABEL: @test_volatile
   // CHECK:      %[[i_addr:.*]] = alloca i32
   // CHECK-NEXT: %[[atomicdst:.*]] = alloca i32
   // CHECK-NEXT: store i32* %i, i32* addrspace(5)* %[[i_addr]]

llvm/lib/AsmParser/LLParser.cpp

if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
       parseScopeAndOrdering(true /*Always atomic*/, SSID, SuccessOrdering) ||
       parseOrdering(FailureOrdering) ||
       parseOptionalCommaAlign(Alignment, AteExtraComma))
     return true;
 
   if (SuccessOrdering == AtomicOrdering::Unordered ||
       FailureOrdering == AtomicOrdering::Unordered)
     return tokError("cmpxchg cannot be unordered");
-  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())
     return error(CmpLoc, "compare value and pointer type do not match");

llvm/lib/IR/Instructions.cpp

assert(getOperand(1)->getType() ==
          && "Ptr must be a pointer to Cmp type!");
   assert(getOperand(2)->getType() ==
                  cast<PointerType>(getOperand(0)->getType())->getElementType()
          && "Ptr must be a pointer to NewVal type!");
   assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
          "AtomicCmpXchg instructions must be atomic!");
   assert(FailureOrdering != AtomicOrdering::NotAtomic &&
          "AtomicCmpXchg instructions must be atomic!");
-  assert(!isStrongerThan(FailureOrdering, SuccessOrdering) &&
-         "AtomicCmpXchg failure argument shall be no stronger than the success "
-         "argument");
   assert(FailureOrdering != AtomicOrdering::Release &&
          FailureOrdering != AtomicOrdering::AcquireRelease &&
          "AtomicCmpXchg failure ordering cannot include release semantics");
 }
 
 AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
                                      Align Alignment,
                                      AtomicOrdering SuccessOrdering,

llvm/lib/IR/Verifier.cpp

void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
   Assert(CXI.getSuccessOrdering() != AtomicOrdering::NotAtomic,
          "cmpxchg instructions must be atomic.", &CXI);
   Assert(CXI.getFailureOrdering() != AtomicOrdering::NotAtomic,
          "cmpxchg instructions must be atomic.", &CXI);
   Assert(CXI.getSuccessOrdering() != AtomicOrdering::Unordered,
          "cmpxchg instructions cannot be unordered.", &CXI);
   Assert(CXI.getFailureOrdering() != AtomicOrdering::Unordered,
          "cmpxchg instructions cannot be unordered.", &CXI);
-  Assert(!isStrongerThan(CXI.getFailureOrdering(), CXI.getSuccessOrdering()),
-         "cmpxchg instructions failure argument shall be no stronger than the "
-         "success argument",
-         &CXI);
   Assert(CXI.getFailureOrdering() != AtomicOrdering::Release &&
              CXI.getFailureOrdering() != AtomicOrdering::AcquireRelease,
          "cmpxchg failure ordering cannot include release semantics", &CXI);
 
   PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
   Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI);
   Type *ElTy = PTy->getElementType();
   Assert(ElTy->isIntOrPtrTy(),