[IR] Introduce llvm.experimental.provenance[begin,end] (#3211)

An experimental intrinisc and a builtin to provide a way to specify that
the pointer is not aliasing with others.

Helpful in cases where pointers are based on the same global value but
with different indices.

Author: sstipano

clang/include/clang/Basic/Builtins.td

@@ -1196,6 +1196,18 @@ def Trap : Builtin {
   let Prototype = "void()";
 }
 
+def ProvenanceBegin : Builtin {
+  let Spellings = ["__builtin_experimental_provenance_begin"];
+  let Attributes = [NoThrow];
+  let Prototype = "void*(void*)";
+}
+
+def ProvenanceEnd : Builtin {
+  let Spellings = ["__builtin_experimental_provenance_end"];
+  let Attributes = [NoThrow];
+  let Prototype = "void(void*)";
+}
+
 def VerboseTrap : Builtin {
   let Spellings = ["__builtin_verbose_trap"];
   let Attributes = [NoThrow, NoReturn];

clang/lib/CodeGen/CGBuiltin.cpp

@@ -3733,6 +3733,20 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   case Builtin::BI__builtin_trap:
     EmitTrapCall(Intrinsic::trap);
     return RValue::get(nullptr);
+  case Builtin::BI__builtin_experimental_provenance_begin:{
+    Value *Ptr = EmitScalarExpr(E->getArg(0));
+    SmallVector<Value *, 2> Args;
+    for (int i = 0, e = E->getNumArgs(); i != e; ++i)
+      Args.push_back(EmitScalarExpr(E->getArg(i)));
+    Function *F = CGM.getIntrinsic(Intrinsic::experimental_provenance_begin, {ConvertType(E->getType()), Ptr->getType()});
+    return RValue::get(Builder.CreateCall(F, {Args}));
+  }
+  case Builtin::BI__builtin_experimental_provenance_end:{
+    Value *Ptr = EmitScalarExpr(E->getArg(0));
+    Function *F = CGM.getIntrinsic(Intrinsic::experimental_provenance_end, Ptr->getType());
+    Builder.CreateCall(F, {Ptr});
+    return RValue::get(nullptr);
+  }
   case Builtin::BI__builtin_verbose_trap: {
     llvm::DILocation *TrapLocation = Builder.getCurrentDebugLocation();
     if (getDebugInfo()) {

clang/test/CodeGen/builtin-experimental-provenance.cpp

@@ -0,0 +1,24 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5
+// RUN: %clang_cc1 -cc1 -triple x86_64-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s
+
+static_assert(__has_builtin(__builtin_experimental_provenance_begin), "");
+static_assert(__has_builtin(__builtin_experimental_provenance_end), "");
+
+void *Ptr;
+
+// CHECK-LABEL: define dso_local void @_Z4testv(
+// CHECK-SAME: ) #[[ATTR0:[0-9]+]] {
+// CHECK-NEXT:  [[ENTRY:.*:]]
+// CHECK-NEXT:    [[PTRPROV:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr @Ptr, align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr @Ptr, align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = call ptr @llvm.experimental.provenance.begin.p0.p0(ptr [[TMP1]])
+// CHECK-NEXT:    store ptr [[TMP2]], ptr [[PTRPROV]], align 8
+// CHECK-NEXT:    [[TMP3:%.*]] = load ptr, ptr [[PTRPROV]], align 8
+// CHECK-NEXT:    call void @llvm.experimental.provenance.end.p0(ptr [[TMP3]])
+// CHECK-NEXT:    ret void
+//
+void test(){
+    void *PtrProv = __builtin_experimental_provenance_begin(Ptr);
+    __builtin_experimental_provenance_end(PtrProv);
+}

llvm/include/llvm/IR/Intrinsics.td

@@ -1670,6 +1670,15 @@ def int_invariant_end   : DefaultAttrsIntrinsic<[],
                                      NoCapture<ArgIndex<2>>,
                                      ImmArg<ArgIndex<1>>]>;
 
+def int_experimental_provenance_begin : Intrinsic<
+                                    [llvm_anyptr_ty], [llvm_anyptr_ty],
+                                    [IntrArgMemOnly, NoAlias<RetIndex>]>,
+                                    ClangBuiltin<"__builtin_experimental_provenance_begin">;
+
+def int_experimental_provenance_end : Intrinsic<
+                                    [], [llvm_anyptr_ty], []>,
+                                    ClangBuiltin<"__builtin_experimental_provenance_end">;
+
 // launder.invariant.group can't be marked with 'readnone' (IntrNoMem),
 // because it would cause CSE of two barriers with the same argument.
 // Inaccessiblememonly says that the barrier doesn't read the argument,

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

@@ -156,6 +156,7 @@ static ModRefInfo GetLocation(const Instruction *Inst, MemoryLocation &Loc,
       // will allow them to be handled conservatively.
       return ModRefInfo::Mod;
     case Intrinsic::invariant_end:
+    case Intrinsic::experimental_provenance_end:
       Loc = MemoryLocation::getForArgument(II, 2, TLI);
       // These intrinsics don't really modify the memory, but returning Mod
       // will allow them to be handled conservatively.

llvm/lib/Analysis/MemorySSA.cpp

@@ -300,6 +300,7 @@ instructionClobbersQuery(const MemoryDef *MD, const MemoryLocation &UseLoc,
     case Intrinsic::assume:
     case Intrinsic::experimental_noalias_scope_decl:
     case Intrinsic::pseudoprobe:
+    case Intrinsic::experimental_provenance_end:
       return false;
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_label:

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

@@ -824,6 +824,7 @@ bool isNoopIntrinsic(Instruction *I) {
     case Intrinsic::invariant_end:
     case Intrinsic::launder_invariant_group:
     case Intrinsic::assume:
+    case Intrinsic::experimental_provenance_end:
       return true;
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_label:

llvm/test/Analysis/BasicAA/experimental-provenance.ll

@@ -0,0 +1,11 @@
+; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
+
+define void @test(ptr %g) {
+; CHECK-LABEL: test
+; CHECK: NoAlias:      i32* %g, i32* %p1.p
+  %p1.p = call ptr @llvm.experimental.provenance.begin(ptr %g)
+  %r1 = load i32, ptr %g
+  %r2 = load i32, ptr %p1.p
+  call void @llvm.experimental.provenance.end(ptr %p1.p)
+  ret void
+}

llvm/test/Transforms/DeadStoreElimination/experimental-provenance.ll

@@ -0,0 +1,29 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt -passes=dse -S < %s | FileCheck %s
+
+@g = global [100 x i32] zeroinitializer
+
+define i32 @test(i32 %i1, i32 %i2, i32 %i3) {
+; CHECK-LABEL: define i32 @test(
+; CHECK-SAME: i32 [[I1:%.*]], i32 [[I2:%.*]], i32 [[I3:%.*]]) {
+; CHECK-NEXT:    [[P1:%.*]] = getelementptr i32, ptr @g, i32 [[I1]]
+; CHECK-NEXT:    [[P2:%.*]] = getelementptr i32, ptr @g, i32 [[I2]]
+; CHECK-NEXT:    [[P1_P:%.*]] = call ptr @llvm.experimental.provenance.begin.p0.p0(ptr [[P1]])
+; CHECK-NEXT:    [[R:%.*]] = load i32, ptr [[P2]], align 4
+; CHECK-NEXT:    store i32 1, ptr [[P1_P]], align 4
+; CHECK-NEXT:    call void @llvm.experimental.provenance.end.p0(ptr [[P1_P]])
+; CHECK-NEXT:    [[R1:%.*]] = load i32, ptr [[P1_P]], align 4
+; CHECK-NEXT:    [[R2:%.*]] = add i32 [[R]], [[R1]]
+; CHECK-NEXT:    ret i32 [[R2]]
+;
+  %p1 = getelementptr i32, ptr @g, i32 %i1
+  %p2 = getelementptr i32, ptr @g, i32 %i2
+  %p1.p = call ptr @llvm.experimental.provenance.begin(ptr %p1)
+  store i32 0, ptr %p1.p
+  %r = load i32, ptr %p2
+  store i32 1, ptr %p1.p
+  call void @llvm.experimental.provenance.end(ptr %p1.p)
+  %r1 = load i32, ptr %p1.p
+  %r2 = add i32 %r, %r1
+  ret i32 %r2
+}