[ptr_provenance] Introduce llvm.experimental.ptr.provenance

[jeroen.dobbelaere]

Summary

The llvm.experimental.ptr.provenance intrinsics combines a pointer value (=operand 0) with a pointer provenance (= operand 1).
This intrinsic is provided so that the provenance can be tracked when a pointer (with provenance) is returned, passed to a function, stored into memory.

When loading and storing through such a pointer, the intrinsic can be omited and the operand 1 can be connected to the ptr_provenance operand of the load/store instructions.

[jeroen.dobbelaere]

• Rebased

[MatzeB]

Please document in the LLVM language reference.

[nikic]

llvm/include/llvm/IR/Intrinsics.td

606

IRBuilder asserts that both types are the same, so make the second one LLVMMatchType<0> as well?

607

This can also be NoCapture<ArgIndex<1>> I believe. (The first argument is capturing, because the pointer is returned.)

[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)

[nikic]

llvm/include/llvm/IR/Intrinsics.td

607

Ignore this comment -- we currently don't distinguish between address and provenance capture, so annotating it would likely not be correct.

llvm/include/llvm/IR/IRBuilder.h

public:
 
   /// Create a llvm.experimental.noalias.scope.decl intrinsic call.
   Instruction *CreateNoAliasScopeDeclaration(Value *Scope);
   Instruction *CreateNoAliasScopeDeclaration(MDNode *ScopeTag) {
     return CreateNoAliasScopeDeclaration(
         MetadataAsValue::get(Context, ScopeTag));
   }
 
+  /// Create a llvm.experimental.ptr.provenance intrinsic call.
+  Instruction *CreatePtrProvenance(Value *PtrValue, Value *PtrProvenance);
+
   /// Create a call to the experimental.gc.statepoint intrinsic to
   /// start a new statepoint sequence.
   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                    FunctionCallee ActualCallee,
                                    ArrayRef<Value *> CallArgs,
                                    std::optional<ArrayRef<Value *>> DeoptArgs,
                                    ArrayRef<Value *> GCArgs,
                                    const Twine &Name = "");

llvm/include/llvm/IR/Intrinsics.td

 // is only valid inside the body of a loop.
 //
 // Purpose of the different arguments:
 // - arg0: id.scope: metadata representing the scope declaration.
 def int_experimental_noalias_scope_decl
     : DefaultAttrsIntrinsic<[], [llvm_metadata_ty],
         [IntrInaccessibleMemOnly]>; // blocks LICM and some more
 
+// 'llvm.experimental.ptr.provenance' intrinsic: Associates a (different)
+// ptr_provenance path to the pointer value. This serves as a guard for pointers
+// that escape through function arguments, through memory or are returned.
+// For Load/Store instructions, there is a separate ptr_provenance operand for
+// tracking the provenance of the pointer operand.
+//
+// Purpose of the different arguments:
+// - arg0: p.val: the incoming pointer value.
+// - arg1: p.prov: the ptr_provenance, associated with this pointer
+//         computation.
+// - returns: arg0 (hidden for most optimization passes)
+def int_experimental_ptr_provenance
+    : DefaultAttrsIntrinsic<[llvm_anyptr_ty],
+                [LLVMMatchType<0>, llvm_anyptr_ty],
+                [IntrNoMem, IntrSpeculatable]>; // NOTE: Returned<0> must not be used here
+
 // Stack Protector Intrinsic - The stackprotector intrinsic writes the stack
 // guard to the correct place on the stack frame.
 def int_stackprotector : DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_ptrptr_ty], []>;
 def int_stackguard : DefaultAttrsIntrinsic<[llvm_ptr_ty], [], []>;
 
 // A cover for instrumentation based profiling.
 def int_instrprof_cover : Intrinsic<[], [llvm_ptr_ty, llvm_i64_ty,
                                          llvm_i32_ty, llvm_i32_ty]>;

llvm/lib/IR/IRBuilder.cpp

 
 Instruction *IRBuilderBase::CreateNoAliasScopeDeclaration(Value *Scope) {
   Module *M = BB->getModule();
   auto *FnIntrinsic = Intrinsic::getDeclaration(
       M, Intrinsic::experimental_noalias_scope_decl, {});
   return CreateCall(FnIntrinsic, {Scope});
 }
 
+Instruction *IRBuilderBase::CreatePtrProvenance(Value *PtrValue,
+                                                Value *PtrProvenance) {
+  assert(PtrValue->getType() == PtrProvenance->getType() &&
+         "pointer and provenance must have the same type");
+  Module *M = BB->getModule();
+  auto *FnIntrinsic =
+      Intrinsic::getDeclaration(M, Intrinsic::experimental_ptr_provenance,
+                                {PtrValue->getType(), PtrValue->getType()});
+  return createCallHelper(FnIntrinsic, {PtrValue, PtrProvenance});
+}
+
 /// Create a call to a Masked Load intrinsic.
 /// \p Ty        - vector type to load
 /// \p Ptr       - base pointer for the load
 /// \p Alignment - alignment of the source location
 /// \p Mask      - vector of booleans which indicates what vector lanes should
 ///                be accessed in memory
 /// \p PassThru  - pass-through value that is used to fill the masked-off lanes
 ///                of the result

llvm/unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, PtrProvenanceLoadStore) {
 
   S->removePtrProvenanceOperand();
   EXPECT_TRUE(!S->hasPtrProvenanceOperand());
 
   EXPECT_EQ(L->getPtrProvenance(), GV);
   EXPECT_EQ(S->getPtrProvenance(), GV);
 }
 
+TEST_F(IRBuilderTest, PtrProvenanceIntrinsics) {
+  IRBuilder<> Builder(BB);
+  auto *A = Builder.CreateAlloca(GV->getValueType());
+
+  auto *PP = Builder.CreatePtrProvenance(GV, A);
+  IntrinsicInst *II_PP = dyn_cast<IntrinsicInst>(PP);
+  ASSERT_TRUE(II_PP != nullptr);
+  EXPECT_EQ(II_PP->getIntrinsicID(), Intrinsic::experimental_ptr_provenance);
+  EXPECT_EQ(PP->getOperand(0), GV);
+  EXPECT_EQ(PP->getOperand(1), A);
+}
+
 TEST_F(IRBuilderTest, Lifetime) {
   IRBuilder<> Builder(BB);
   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
   AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
   AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
                                           Builder.getInt32(123));
 
   CallInst *Start1 = Builder.CreateLifetimeStart(Var1);