Correctly generate invert xor value for Binary Atomics of int size > 64

[jyu2]

Summary

When using sync_nand_and_fetch with int128, a problem is found that
the wrong value for the 'invert' value gets emitted to the xor in case
where the int size is greater than 64 bits.

This is because uses of llvm::ConstantInt::get which zero extends the
greater than 64 bits, so instead -1 that we require, it end up
getting 18446744073709551615

This patch replaces the call to llvm::ConstantInt::get with the call
to llvm::Constant::getAllOnesValue which works for all integer types.

[jfb]

This amused me.

[hiraditya]

Nice find!

clang/lib/CodeGen/CGBuiltin.cpp

static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF,
   llvm::Type *ValueType = Args[1]->getType();
   Args[1] = EmitToInt(CGF, Args[1], T, IntType);
   Args[0] = CGF.Builder.CreateBitCast(DestPtr, IntPtrType);
 
   llvm::Value *Result = CGF.Builder.CreateAtomicRMW(
       Kind, Args[0], Args[1], llvm::AtomicOrdering::SequentiallyConsistent);
   Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
   if (Invert)
-    Result = CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,
-                                     llvm::ConstantInt::get(IntType, -1));
+    Result =
+        CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,
+                                llvm::ConstantInt::getAllOnesValue(IntType));
   Result = EmitFromInt(CGF, Result, T, ValueType);
   return RValue::get(Result);
 }
 
 /// Utility to insert an atomic cmpxchg instruction.
 ///
 /// @param CGF The current codegen function.
 /// @param E   Builtin call expression to convert to cmpxchg.

clang/test/CodeGen/Atomics.c

 // Test frontend handling of __sync builtins.
 // Modified from a gcc testcase.
 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -o - | FileCheck %s
 
 signed char sc;
 unsigned char uc;
 signed short ss;
 unsigned short us;
 signed int si;
 unsigned int ui;
 signed long long sll;
 unsigned long long ull;
+__int128 s128;
+unsigned  __int128 u128;
 
 void test_op_ignore (void) // CHECK-LABEL: define void @test_op_ignore
 {
   (void) __sync_fetch_and_add (&sc, 1); // CHECK: atomicrmw add i8
   (void) __sync_fetch_and_add (&uc, 1); // CHECK: atomicrmw add i8
   (void) __sync_fetch_and_add (&ss, 1); // CHECK: atomicrmw add i16
   (void) __sync_fetch_and_add (&us, 1); // CHECK: atomicrmw add i16
   (void) __sync_fetch_and_add (&si, 1); // CHECK: atomicrmw add i32
void test_op_ignore (void) // CHECK-LABEL: define void @test_op_ignore
   (void) __sync_fetch_and_xor (&sc, 1); // CHECK: atomicrmw xor i8
   (void) __sync_fetch_and_xor (&uc, 1); // CHECK: atomicrmw xor i8
   (void) __sync_fetch_and_xor (&ss, 1); // CHECK: atomicrmw xor i16
   (void) __sync_fetch_and_xor (&us, 1); // CHECK: atomicrmw xor i16
   (void) __sync_fetch_and_xor (&si, 1); // CHECK: atomicrmw xor i32
   (void) __sync_fetch_and_xor (&ui, 1); // CHECK: atomicrmw xor i32
   (void) __sync_fetch_and_xor (&sll, 1); // CHECK: atomicrmw xor i64
   (void) __sync_fetch_and_xor (&ull, 1); // CHECK: atomicrmw xor i64
+  (void) __sync_fetch_and_xor (&u128, 1); // CHECK: atomicrmw xor i128
+  (void) __sync_fetch_and_xor (&s128, 1); // CHECK: atomicrmw xor i128
 
   (void) __sync_fetch_and_nand (&sc, 1); // CHECK: atomicrmw nand i8
   (void) __sync_fetch_and_nand (&uc, 1); // CHECK: atomicrmw nand i8
   (void) __sync_fetch_and_nand (&ss, 1); // CHECK: atomicrmw nand i16
   (void) __sync_fetch_and_nand (&us, 1); // CHECK: atomicrmw nand i16
   (void) __sync_fetch_and_nand (&si, 1); // CHECK: atomicrmw nand i32
   (void) __sync_fetch_and_nand (&ui, 1); // CHECK: atomicrmw nand i32
   (void) __sync_fetch_and_nand (&sll, 1); // CHECK: atomicrmw nand i64
void test_op_and_fetch (void)
   si = __sync_xor_and_fetch (&si, uc); // CHECK: atomicrmw xor
   ui = __sync_xor_and_fetch (&ui, uc); // CHECK: atomicrmw xor
   sll = __sync_xor_and_fetch (&sll, uc); // CHECK: atomicrmw xor
   ull = __sync_xor_and_fetch (&ull, uc); // CHECK: atomicrmw xor
 
   sc = __sync_nand_and_fetch (&sc, uc); // CHECK: atomicrmw nand
                                         // CHECK: and
                                         // CHECK: xor
+                                        // CHECK: -1
   uc = __sync_nand_and_fetch (&uc, uc); // CHECK: atomicrmw nand
                                         // CHECK: and
                                         // CHECK: xor
+                                        // CHECK: -1
   ss = __sync_nand_and_fetch (&ss, uc); // CHECK: atomicrmw nand
                                         // CHECK: and
                                         // CHECK: xor
+                                        // CHECK: -1
   us = __sync_nand_and_fetch (&us, uc); // CHECK: atomicrmw nand
                                         // CHECK: and
                                         // CHECK: xor
+                                        // CHECK: -1
   si = __sync_nand_and_fetch (&si, uc); // CHECK: atomicrmw nand
                                         // CHECK: and
                                         // CHECK: xor
+                                        // CHECK: -1
   ui = __sync_nand_and_fetch (&ui, uc); // CHECK: atomicrmw nand
                                         // CHECK: and
                                         // CHECK: xor
+                                        // CHECK: -1
   sll = __sync_nand_and_fetch (&sll, uc); // CHECK: atomicrmw nand
                                           // CHECK: and
                                           // CHECK: xor
+                                          // CHECK: -1
   ull = __sync_nand_and_fetch (&ull, uc); // CHECK: atomicrmw nand
                                           // CHECK: and
                                           // CHECK: xor
+                                          // CHECK: -1
+  u128 = __sync_nand_and_fetch (&u128, uc); // CHECK: atomicrmw nand
+                                          // CHECK: and
+                                          // CHECK: xor
+                                          // CHECK: -1
+  s128 = __sync_nand_and_fetch (&s128, uc); // CHECK: atomicrmw nand
+                                          // CHECK: and
+                                          // CHECK: xor
+                                          // CHECK: -1
 
   sc = __sync_and_and_fetch (&sc, uc); // CHECK: atomicrmw and
   uc = __sync_and_and_fetch (&uc, uc); // CHECK: atomicrmw and
   ss = __sync_and_and_fetch (&ss, uc); // CHECK: atomicrmw and
   us = __sync_and_and_fetch (&us, uc); // CHECK: atomicrmw and
   si = __sync_and_and_fetch (&si, uc); // CHECK: atomicrmw and
   ui = __sync_and_and_fetch (&ui, uc); // CHECK: atomicrmw and
   sll = __sync_and_and_fetch (&sll, uc); // CHECK: atomicrmw and