Expose IRBuilder::CreateAtomicCmpXchg as LLVMBuildAtomicCmpXchg in th…

…e C API. Summary: Also expose getters and setters in the C API, so that the change can be tested. Reviewers: nhaehnle, axw, joker.eph Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D18260 From: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl> git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@263886 91177308-0d34-0410-b5e6-96231b3b80d8
llvm-mirror · Mar 19, 2016 · e6cda0e9bc5f413814bb25f532ff97e90283106d · e6cda0e
1 parent 14e4632
commit e6cda0e9bc5f413814bb25f532ff97e90283106d
Unified Split

Showing with 91 additions and 0 deletions.

+15 −0 include/llvm-c/Core.h

+55 −0 lib/IR/Core.cpp

+10 −0 test/Bindings/llvm-c/atomics.ll

+11 −0 tools/llvm-c-test/echo.cpp
diff --git a/include/llvm-c/Core.h b/include/llvm-c/Core.h
@@ -2940,6 +2940,21 @@ LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
                                LLVMValueRef PTR, LLVMValueRef Val,
                                LLVMAtomicOrdering ordering,
                                LLVMBool singleThread);
+  
+LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
+  
+                                    LLVMValueRef Cmp, LLVMValueRef New,
+  
+                                    LLVMAtomicOrdering SuccessOrdering,
+  
+                                    LLVMAtomicOrdering FailureOrdering,
+  
+                                    LLVMBool SingleThread);
+  
+
+  
+LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst);
+  
+void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread);
+  
+
+  
+LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst);
+  
+void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
+  
+                                   LLVMAtomicOrdering Ordering);
+  
+LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst);
+  
+void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
+  
+                                   LLVMAtomicOrdering Ordering);
 /**
 * @}

diff --git a/lib/IR/Core.cpp b/lib/IR/Core.cpp
@@ -2908,6 +2908,61 @@ LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
    mapFromLLVMOrdering(ordering), singleThread ? SingleThread : CrossThread));
 }
+  
+LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
+  
+                                    LLVMValueRef Cmp, LLVMValueRef New,
+  
+                                    LLVMAtomicOrdering SuccessOrdering,
+  
+                                    LLVMAtomicOrdering FailureOrdering,
+  
+                                    LLVMBool singleThread) {
+  
+
+  
+  return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp),
+  
+                unwrap(New), mapFromLLVMOrdering(SuccessOrdering),
+  
+                mapFromLLVMOrdering(FailureOrdering),
+  
+                singleThread ? SingleThread : CrossThread));
+  
+}
+  
+
+  
+
+  
+LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
+  
+  Value *P = unwrap<Value>(AtomicInst);
+  
+
+  
+  if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
+  
+    return I->getSynchScope() == SingleThread;
+  
+  return cast<AtomicCmpXchgInst>(P)->getSynchScope() == SingleThread;
+  
+}
+  
+
+  
+void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue) {
+  
+  Value *P = unwrap<Value>(AtomicInst);
+  
+  SynchronizationScope Sync = NewValue ? SingleThread : CrossThread;
+  
+
+  
+  if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
+  
+    return I->setSynchScope(Sync);
+  
+  return cast<AtomicCmpXchgInst>(P)->setSynchScope(Sync);
+  
+}
+  
+
+  
+LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst)  {
+  
+  Value *P = unwrap<Value>(CmpXchgInst);
+  
+  return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getSuccessOrdering());
+  
+}
+  
+
+  
+void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
+  
+                                   LLVMAtomicOrdering Ordering) {
+  
+  Value *P = unwrap<Value>(CmpXchgInst);
+  
+  AtomicOrdering O = mapFromLLVMOrdering(Ordering);
+  
+
+  
+  return cast<AtomicCmpXchgInst>(P)->setSuccessOrdering(O);
+  
+}
+  
+
+  
+LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst)  {
+  
+  Value *P = unwrap<Value>(CmpXchgInst);
+  
+  return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getFailureOrdering());
+  
+}
+  
+
+  
+void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
+  
+                                   LLVMAtomicOrdering Ordering) {
+  
+  Value *P = unwrap<Value>(CmpXchgInst);
+  
+  AtomicOrdering O = mapFromLLVMOrdering(Ordering);
+  
+
+  
+  return cast<AtomicCmpXchgInst>(P)->setFailureOrdering(O);
+  
+}
 /*===-- Module providers --------------------------------------------------===*/

diff --git a/test/Bindings/llvm-c/atomics.ll b/test/Bindings/llvm-c/atomics.ll
@@ -0,0 +1,10 @@
+  
+; RUN: llvm-as < %s | llvm-dis > %t.orig
+  
+; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
+  
+; RUN: diff -w %t.orig %t.echo
+  
+
+  
+define i32 @main() {
+  
+  %1 = alloca i32
+  
+  %2 = cmpxchg i32* %1, i32 2, i32 3 seq_cst acquire
+  
+  %3 = extractvalue { i32, i1 } %2, 0
+  
+  ret i32 %3
+  
+}
diff --git a/tools/llvm-c-test/echo.cpp b/tools/llvm-c-test/echo.cpp
@@ -522,6 +522,17 @@ struct FunCloner {
          Dst = LLVMBuildGEP(Builder, Ptr, Idx.data(), NumIdx, Name);
        break;
      }
+  
+      case LLVMAtomicCmpXchg: {
+  
+        LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
+  
+        LLVMValueRef Cmp = CloneValue(LLVMGetOperand(Src, 1));
+  
+        LLVMValueRef New = CloneValue(LLVMGetOperand(Src, 2));
+  
+        LLVMAtomicOrdering Succ = LLVMGetCmpXchgSuccessOrdering(Src);
+  
+        LLVMAtomicOrdering Fail = LLVMGetCmpXchgFailureOrdering(Src);
+  
+        LLVMBool SingleThread = LLVMIsAtomicSingleThread(Src);
+  
+
+  
+        Dst = LLVMBuildAtomicCmpXchg(Builder, Ptr, Cmp, New, Succ, Fail,
+  
+                                     SingleThread);
+  
+      } break;
      case LLVMBitCast: {
        LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 0));
        Dst = LLVMBuildBitCast(Builder, V, CloneType(Src), Name);