[CIR] Fix for __atomic_compare_exchange weak arg (#721)

ClangIR was failing on
```
__atomic_compare_exchange_n(&a, &old, 42, true, 5, 5);
```
The `true` was the problem. It would work with a literal `0` or `1`, but
not with a literal `true` or `false`.

The bug was in `isCstWeak` in CIRGenAtomic.cpp, which was only looking
for an integral constant. It didn't recognize a boolean constant and was
falling back on the non-constant path, which isn't implemented yet.

Rewrite `isCstWeak` to check for both intergral and boolean constants.

Author: dkolsen-pgi

clang/lib/CIR/CodeGen/CIRGenAtomic.cpp

@@ -348,12 +348,25 @@ static mlir::cir::IntAttr getConstOpIntAttr(mlir::Value v) {
   return constVal;
 }
 
-static bool isCstWeak(mlir::Value weakVal, uint64_t &val) {
-  auto intAttr = getConstOpIntAttr(weakVal);
-  if (!intAttr)
-    return false;
-  val = intAttr.getUInt();
-  return true;
+// Inspect a value that is the strong/weak flag for a compare-exchange.  If it
+// is a constant of intergral or boolean type, set `val` to the constant's
+// boolean value and return true.  Otherwise leave `val` unchanged and return
+// false.
+static bool isCstWeak(mlir::Value weakVal, bool &val) {
+  mlir::Operation *op = weakVal.getDefiningOp();
+  while (auto c = dyn_cast<mlir::cir::CastOp>(op)) {
+    op = c.getOperand().getDefiningOp();
+  }
+  if (auto c = dyn_cast<mlir::cir::ConstantOp>(op)) {
+    if (mlir::isa<mlir::cir::IntType>(c.getType())) {
+      val = mlir::cast<mlir::cir::IntAttr>(c.getValue()).getUInt() != 0;
+      return true;
+    } else if (mlir::isa<mlir::cir::BoolType>(c.getType())) {
+      val = mlir::cast<mlir::cir::BoolAttr>(c.getValue()).getValue();
+      return true;
+    }
+  }
+  return false;
 }
 
 static void buildAtomicCmpXchg(CIRGenFunction &CGF, AtomicExpr *E, bool IsWeak,
@@ -470,7 +483,7 @@ static void buildAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
   case AtomicExpr::AO__atomic_compare_exchange_n:
   case AtomicExpr::AO__scoped_atomic_compare_exchange:
   case AtomicExpr::AO__scoped_atomic_compare_exchange_n: {
-    uint64_t weakVal;
+    bool weakVal;
     if (isCstWeak(IsWeak, weakVal)) {
       buildAtomicCmpXchgFailureSet(CGF, E, weakVal, Dest, Ptr, Val1, Val2,
                                    FailureOrder, Size, Order, Scope);

clang/test/CIR/CodeGen/atomic.cpp

@@ -260,7 +260,7 @@ bool fd4(struct S *a, struct S *b, struct S *c) {
 bool fi4a(int *i) {
   int cmp = 0;
   int desired = 1;
-  return __atomic_compare_exchange(i, &cmp, &desired, 0, memory_order_acquire, memory_order_acquire);
+  return __atomic_compare_exchange(i, &cmp, &desired, false, memory_order_acquire, memory_order_acquire);
 }
 
 // CHECK-LABEL: @_Z4fi4aPi
@@ -273,7 +273,7 @@ bool fi4a(int *i) {
 
 bool fi4b(int *i) {
   int cmp = 0;
-  return __atomic_compare_exchange_n(i, &cmp, 1, 1, memory_order_acquire, memory_order_acquire);
+  return __atomic_compare_exchange_n(i, &cmp, 1, true, memory_order_acquire, memory_order_acquire);
 }
 
 // CHECK-LABEL: @_Z4fi4bPi
@@ -470,4 +470,4 @@ void cmp_val_short(short* p, short x, short u) {
 // LLVM: cmpxchg ptr {{.*}}, i8 {{.*}}, i8 {{.*}} seq_cst seq_cst
 void cmp_val_byte(char* p, char x, char u) {
   char r = __sync_val_compare_and_swap(p, x, u);
-}
+}