[ptr_provenance] Add llvm-c support.

[jeroen.dobbelaere]

Summary

This introduces LLVMExperimentalGetPtrProvenanceOperand and LLVMExperimentalSetPtrProvenanceOperand. They can be used to get/set/remove the ptr_provenance operand of a load or store instruction.

[deadalnix]

llvm/tools/llvm-c-test/echo.cpp

635

You need to clone the values, just like it is done for the Ptr one.

First, it ensures that the value is generated properly, but second, these value belong to different (even though identical if the test passes) modules. This is not expected to work and kind of is a miracle that this doesn't crash.

646

dito

[jeroen.dobbelaere]

Fixed test crash issue as suggested by @deadalnix

[jeroen.dobbelaere]

Actual fixed version.

[deadalnix]

I think using nullptr would be preferable, but this looks good. Thanks.

llvm/lib/IR/Core.cpp

3715

I missed this on the first pass, but this is a C++ file, so you can simply return nullptr.

[jeroen.dobbelaere]

Rebase to 49cb4fef02e635bf304906232214166c7531d753

[jeroen.dobbelaere]

Rebased to ffe262a198a9f9030991df6d3ddd812e74fa3523

[jeroen.dobbelaere]

Rebased to ef545ef62a833152d8975ff16333b57cc41befcc (Jan 9, 2023)

[jeroen.dobbelaere]

Rebased to: 8c7cfa357280dd93d33b10bbba0fe33797e27d63 (Feb 14, 2023)

llvm/include/llvm-c/Core.h

 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
 LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst);
 void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool IsWeak);
 LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst);
 void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering);
 LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst);
 void LLVMSetAtomicRMWBinOp(LLVMValueRef AtomicRMWInst, LLVMAtomicRMWBinOp BinOp);
 
+/**
+ * \returns the ptr_provenance operand of a load/store instruction. Returns a
+ * NULL if the load/store instruction does not has a ptr_provenance operand.
+ */
+LLVMValueRef
+LLVMExperimentalGetPtrProvenanceOperand(LLVMValueRef LoadOrStoreInst);
+
+/**
+ * Sets or removes the optional ptr_provenance operand of a load/store
+ * instruction. When a NULL is passed as PtrProvenance, the ptr_provenance
+ * operand will be removed.
+ */
+void LLVMExperimentalSetPtrProvenanceOperand(LLVMValueRef LoadOrStoreInst,
+                                             LLVMValueRef PtrProvenance);
+
 /* Casts */
 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
                             LLVMTypeRef DestTy, const char *Name);
 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
                            LLVMTypeRef DestTy, const char *Name);
 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val,
                            LLVMTypeRef DestTy, const char *Name);
 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val,

llvm/lib/IR/Core.cpp

 LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef Inst) {
   return mapToLLVMRMWBinOp(unwrap<AtomicRMWInst>(Inst)->getOperation());
 }
 
 void LLVMSetAtomicRMWBinOp(LLVMValueRef Inst, LLVMAtomicRMWBinOp BinOp) {
   unwrap<AtomicRMWInst>(Inst)->setOperation(mapFromLLVMRMWBinOp(BinOp));
 }
 
+LLVMValueRef
+LLVMExperimentalGetPtrProvenanceOperand(LLVMValueRef LoadOrStoreInst) {
+  Value *P = unwrap<Value>(LoadOrStoreInst);
+  if (LoadInst *LI = dyn_cast<LoadInst>(P)) {
+    if (LI->hasPtrProvenanceOperand())
+      return wrap(LI->getPtrProvenanceOperand());
+    else
+      return NULL;
+  } else {
+    StoreInst *SI = cast<StoreInst>(P);
+    if (SI->hasPtrProvenanceOperand())
+      return wrap(SI->getPtrProvenanceOperand());
+    else
+      return NULL;
+  }
+}
+
+void LLVMExperimentalSetPtrProvenanceOperand(LLVMValueRef LoadOrStoreInst,
+                                             LLVMValueRef PtrProvenance) {
+  Value *P = unwrap<Value>(LoadOrStoreInst);
+  if (LoadInst *LI = dyn_cast<LoadInst>(P)) {
+    if (PtrProvenance)
+      LI->setPtrProvenanceOperand(unwrap<Value>(PtrProvenance));
+    else if (LI->hasPtrProvenanceOperand())
+      LI->removePtrProvenanceOperand();
+  } else {
+    StoreInst *SI = cast<StoreInst>(P);
+    if (PtrProvenance)
+      SI->setPtrProvenanceOperand(unwrap<Value>(PtrProvenance));
+    else if (SI->hasPtrProvenanceOperand())
+      SI->removePtrProvenanceOperand();
+  }
+}
+
 /*--.. Casts ...............................................................--*/
 
 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
                             LLVMTypeRef DestTy, const char *Name) {
   return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
 }
 
 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,

llvm/test/Bindings/llvm-c/echo.ll

define void @memops(ptr %ptr) {
   store volatile i8 0, ptr %ptr
   store i8 0, ptr %ptr, align 8
   store atomic i8 0, ptr %ptr release, align 32
   %e = atomicrmw add ptr %ptr, i8 0 monotonic, align 1
   %f = atomicrmw volatile xchg ptr %ptr, i8 0 acq_rel, align 8
   %g = cmpxchg ptr %ptr, i8 1, i8 2 seq_cst acquire, align 1
   %h = cmpxchg weak ptr %ptr, i8 1, i8 2 seq_cst acquire, align 8
   %i = cmpxchg volatile ptr %ptr, i8 1, i8 2 monotonic monotonic, align 16
+  %j = load i8, ptr %ptr, ptr_provenance ptr %ptr
+  %k = load i8, ptr %ptr, ptr_provenance ptr unknown_provenance
+  store i8 0, ptr %ptr, ptr_provenance ptr %ptr
+  store i8 1, ptr %ptr, ptr_provenance ptr unknown_provenance
   ret void
 }
 
 define i32 @vectorops(i32, i32) {
   %a = insertelement <4 x i32> undef, i32 %0, i32 0
   %b = insertelement <4 x i32> %a, i32 %1, i32 2
   %c = shufflevector <4 x i32> %b, <4 x i32> undef, <4 x i32> zeroinitializer
   %d = shufflevector <4 x i32> %c, <4 x i32> %b, <4 x i32> <i32 1, i32 2, i32 3, i32 0>

llvm/tools/llvm-c-test/echo.cpp

switch(Op) {
         break;
       }
       case LLVMLoad: {
         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
         Dst = LLVMBuildLoad2(Builder, CloneType(Src), Ptr, Name);
         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
+        if (LLVMValueRef PtrProv = LLVMExperimentalGetPtrProvenanceOperand(Src))
+          LLVMExperimentalSetPtrProvenanceOperand(Dst, CloneValue(PtrProv));
         break;
       }
       case LLVMStore: {
         LLVMValueRef Val = CloneValue(LLVMGetOperand(Src, 0));
         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 1));
         Dst = LLVMBuildStore(Builder, Val, Ptr);
         LLVMSetAlignment(Dst, LLVMGetAlignment(Src));
         LLVMSetOrdering(Dst, LLVMGetOrdering(Src));
         LLVMSetVolatile(Dst, LLVMGetVolatile(Src));
+        if (LLVMValueRef PtrProv = LLVMExperimentalGetPtrProvenanceOperand(Src))
+          LLVMExperimentalSetPtrProvenanceOperand(Dst, CloneValue(PtrProv));
         break;
       }
       case LLVMGetElementPtr: {
         LLVMTypeRef ElemTy = CloneType(LLVMGetGEPSourceElementType(Src));
         LLVMValueRef Ptr = CloneValue(LLVMGetOperand(Src, 0));
         SmallVector<LLVMValueRef, 8> Idx;
         int NumIdx = LLVMGetNumIndices(Src);
         for (int i = 1; i <= NumIdx; i++)