[PATCH 06/27] [noalias] [IR] IRBuilder support for noalias intrinsics.

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

Note: this is a stable point and tests should run fine with the patches applied up to this point.
Note: D68490 has been incorporated

[lebedev.ri]

llvm/include/llvm/IR/IRBuilder.h

651

But ObjId is uint64_t?

654

Here and elsewhere - currently llvm variable naming scheme did not change, all variables start with Uppercase Letter.

663

Should this be uint32_t ?

671

Should this be uint32_t ?

llvm/include/llvm/IR/IntrinsicInst.h

889–890

assert(lhs->getIntrinsicID() == rhs->getIntrinsicID() && ;hs->getIntrinsicID() == Intrinsic::side_noalias && "Can only check noalias compatibility of side_noalias intrinsics");

891–896

std::tie(<...>) == std::tie(<...>) ?

llvm/lib/IR/IRBuilder.cpp

514

Should this be uint64_t?

565–566

Ops.insert(Ops.end(), MDNodes.begin(), MDNodes.end()) ?

569

same

573–577

This should be in the parent patch that added that

llvm/lib/IR/Verifier.cpp

4760–4761

} else if (auto *PHI = dyn_cast<PHINode>(V)) {

4762–4763

Worklist.insert() ?

[jeroen.dobbelaere]

llvm/include/llvm/IR/IRBuilder.h

651

I am preparing an update where I use uint64_t more consistenly.

llvm/include/llvm/IR/IntrinsicInst.h

891–896

You mean: std::forward_as_tuple ?

llvm/lib/IR/IRBuilder.cpp

514

No. It should be int64_t.

565–566

That won't work.

569

But here it will.

573–577

Maybe. I tried to not do that kind of changes in the rebased versions.

[jeroen.dobbelaere]

Treat objId as uint64_t everywhere; treat indices as int64_t; use std::forward_as_tuple; .use insert instead of for-loop+push_back.

[vermaelen.wouter]

llvm/include/llvm/IR/IntrinsicInst.h

891–896

Doesn't that loose the short-circuit behavior of operator&&?

Detail: IMHO it doesn't really improve readability:

(a == b) && (c == d)

versus

std::tie(a, c) == std::tie(b, d);

[jeroen.dobbelaere]

Yes, using forward_as_tuple might result in slower code... I am reverting that change.

[jeroen.dobbelaere]

Do not use std::forward_as_tuple.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

llvm/include/llvm/IR/IRBuilder.h

CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src,
                          MDNode *ScopeTag = nullptr,
                          MDNode *NoAliasTag = nullptr) {
     return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src,
                                  SrcAlign, Size, isVolatile, TBAATag,
                                  TBAAStructTag, ScopeTag, NoAliasTag);
   }
 
   CallInst *CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,
                                MaybeAlign SrcAlign, Value *Size);
 
   /// Create and insert an element unordered-atomic memcpy between the
   /// specified pointers.
   ///
   /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
   ///
   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
   CallInst *CreateElementUnorderedAtomicMemCpy(
       Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
       uint32_t ElementSize, MDNode *TBAATag = nullptr,
       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
       MDNode *NoAliasTag = nullptr);
 
   CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
                           MaybeAlign SrcAlign, uint64_t Size,
                           bool isVolatile = false, MDNode *TBAATag = nullptr,
                           MDNode *ScopeTag = nullptr,
                           MDNode *NoAliasTag = nullptr) {
     return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
                          isVolatile, TBAATag, ScopeTag, NoAliasTag);
   }
 
   CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
                           MaybeAlign SrcAlign, Value *Size,
                           bool isVolatile = false, MDNode *TBAATag = nullptr,
                           MDNode *ScopeTag = nullptr,
#endif
 
   /// 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.noalias.decl intrinsic call.
+  Instruction *CreateNoAliasDeclaration(Value *AllocaPtr, Value *ObjId,
+                                        Value *Scope);
+  Instruction *CreateNoAliasDeclaration(Value *AllocaPtr, uint64_t ObjId,
+                                        Value *Scope) {
+    return CreateNoAliasDeclaration(
+        AllocaPtr,
+        ConstantInt::get(IntegerType::getInt64Ty(getContext()), ObjId), Scope);
+  }
+  Instruction *CreateNoAliasDeclaration(Value *AllocaPtr, MDNode *ScopeTag) {
+    uint64_t Zero = 0;
+    return CreateNoAliasDeclaration(AllocaPtr, Zero,
+                                    MetadataAsValue::get(Context, ScopeTag));
+  }
+
+  /// Create a llvm.noalias intrinsic call.
+  Instruction *CreateNoAliasPointer(Value *Ptr, Value *NoAliasDecl,
+                                    Value *AddrP, MDNode *ScopeTag,
+                                    const Twine &Name = "",
+                                    uint64_t ObjectId = 0) {
+    return CreateNoAliasPointer(Ptr, NoAliasDecl, AddrP,
+                                MetadataAsValue::get(getContext(), ScopeTag),
+                                Name, ObjectId);
+  }
+  Instruction *CreateNoAliasPointer(Value *Ptr, Value *NoAliasDecl,
+                                    Value *AddrP, Value *ScopeTag,
+                                    const Twine &Name = "",
+                                    uint64_t ObjectId = 0);
+
+  /// Create a llvm.provenance.noalias intrinsic call.
+  Instruction *CreateProvenanceNoAliasPlain(Value *Ptr, Value *NoAliasDecl,
+                                            Value *AddrP,
+                                            Value *AddrP_Provenance,
+                                            Value *ObjId, MDNode *ScopeTag,
+                                            const Twine &Name = "");
+  Instruction *CreateProvenanceNoAliasPlain(Value *Ptr, Value *NoAliasDecl,
+                                            Value *AddrP,
+                                            Value *AddrP_Provenance,
+                                            Value *ObjId, Value *ScopeValue,
+                                            const Twine &Name = "");
+
+  /// Create a llvm.noalias.arg.guard intrinsic call.
+  Instruction *CreateNoAliasArgGuard(Value *Ptr, Value *Provenance,
+                                     const Twine &Name = "");
+
+  /// Create a llvm.noalias_copy_guard intrinsic call.
+  Instruction *CreateNoAliasCopyGuard(Value *BasePtr, Value *NoAliasDel,
+                                      ArrayRef<int64_t> EncodedIndices,
+                                      MDNode *ScopeTag, const Twine &Name = "");
+
+private:
+  /// Helper for creating noalias intrinsics
+  Instruction *CreateGenericNoAliasIntrinsic(Intrinsic::ID ID, Value *arg0,
+                                             ArrayRef<Value *> args_opt,
+                                             ArrayRef<MDNode *> MDNodes,
+                                             ArrayRef<Value *> MDValues,
+                                             const Twine &Name = "");
+
+public:
   /// Create a call to the experimental.gc.statepoint intrinsic to
   /// start a new statepoint sequence.
   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
                                    Value *ActualCallee,
                                    ArrayRef<Value *> CallArgs,
                                    Optional<ArrayRef<Value *>> DeoptArgs,
                                    ArrayRef<Value *> GCArgs,
                                    const Twine &Name = "");

llvm/include/llvm/IR/IntrinsicInst.h

default:
       return false;
     }
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
 /// This class wraps the llvm.memcpy intrinsic.
 class MemCpyInst : public MemTransferInst {
 public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::memcpy;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
 /// This class wraps the llvm.memmove intrinsic.
 class MemMoveInst : public MemTransferInst {
 public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
public:
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::assume;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
+/// Returns true when two llvm.provenance.noalias represent the same noalias
+/// info.
+inline bool areProvenanceNoAliasCompatible(const IntrinsicInst *lhs,
+                                           const IntrinsicInst *rhs) {
+  assert(lhs->getIntrinsicID() == Intrinsic::provenance_noalias &&
+         rhs->getIntrinsicID() == Intrinsic::provenance_noalias &&
+         "Can only check noalias compatibility of provenance.noalias");
+  return (lhs->getOperand(Intrinsic::ProvenanceNoAliasScopeArg) ==
+          rhs->getOperand(Intrinsic::ProvenanceNoAliasScopeArg)) &&
+         (lhs->getOperand(Intrinsic::ProvenanceNoAliasIdentifyPObjIdArg) ==
+          rhs->getOperand(Intrinsic::ProvenanceNoAliasIdentifyPObjIdArg)) &&
+         (lhs->getOperand(Intrinsic::ProvenanceNoAliasIdentifyPArg) ==
+          rhs->getOperand(Intrinsic::ProvenanceNoAliasIdentifyPArg));
+}
 } // end namespace llvm
 
 #endif // LLVM_IR_INTRINSICINST_H

llvm/include/llvm/IR/Intrinsics.h

 
 /// This namespace contains an enum with a value for every intrinsic/builtin
 /// function known by LLVM. The enum values are returned by
 /// Function::getIntrinsicID().
 namespace Intrinsic {
   // Abstraction for the arguments of the noalias intrinsics
   static const int NoAliasScopeDeclScopeArg = 0;
 
+  // Abstraction for the arguments of the noalias intrinsics
+  static const int ProvenanceNoAliasNoAliasDeclArg = 1;
+  static const int ProvenanceNoAliasIdentifyPArg = 2;
+  static const int ProvenanceNoAliasIdentifyPProvenanceArg = 3;
+  static const int ProvenanceNoAliasIdentifyPObjIdArg = 4;
+  static const int ProvenanceNoAliasScopeArg = 5;
+
+  static const int NoAliasNoAliasDeclArg = 1;
+  static const int NoAliasIdentifyPArg = 2;
+  static const int NoAliasIdentifyPObjIdArg = 3;
+  static const int NoAliasScopeArg = 4;
+
+  static const int NoAliasDeclAllocaArg = 0;
+  static const int NoAliasDeclObjIdArg = 1;
+  static const int NoAliasDeclScopeArg = 2;
+
+  static const int NoAliasCopyGuardIdentifyPBaseObject = 0;
+  static const int NoAliasCopyGuardNoAliasDeclArg = 1;
+  static const int NoAliasCopyGuardIndicesArg = 2;
+  static const int NoAliasCopyGuardScopeArg = 3;
+
   // Intrinsic ID type. This is an opaque typedef to facilitate splitting up
   // the enum into target-specific enums.
   typedef unsigned ID;
 
   enum IndependentIntrinsics : unsigned {
     not_intrinsic = 0, // Must be zero
 
   // Get the intrinsic enums generated from Intrinsics.td

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 createCallHelper(FnIntrinsic, {Scope}, this);
 }
 
+Instruction *IRBuilderBase::CreateNoAliasDeclaration(Value *AllocaPtr,
+                                                     Value *ObjId,
+                                                     Value *Scope) {
+  assert(AllocaPtr);
+
+  SmallVector<Type *, 1> Types = {Type::getInt8PtrTy(getContext()),
+                                  AllocaPtr->getType(), ObjId->getType()};
+  SmallVector<Value *, 1> Ops = {AllocaPtr, ObjId, Scope};
+
+  Module *M = BB->getModule();
+  auto *FnIntrinsic =
+      Intrinsic::getDeclaration(M, Intrinsic::noalias_decl, Types);
+  return createCallHelper(FnIntrinsic, Ops, this);
+}
+
+Instruction *IRBuilderBase::CreateNoAliasPointer(Value *Ptr, Value *NoAliasDecl,
+                                                 Value *AddrP, Value *ScopeTag,
+                                                 const Twine &Name,
+                                                 uint64_t ObjectId) {
+  assert(Ptr && AddrP);
+  Value *I64_0 =
+      ConstantInt::get(IntegerType::getInt64Ty(getContext()), ObjectId);
+  return CreateGenericNoAliasIntrinsic(Intrinsic::noalias, Ptr,
+                                       {NoAliasDecl, AddrP, I64_0}, {},
+                                       {ScopeTag}, Name);
+}
+
+Instruction *IRBuilderBase::CreateProvenanceNoAliasPlain(
+    Value *Ptr, Value *NoAliasDecl, Value *AddrP, Value *AddrP_Provenance,
+    Value *ObjId, MDNode *ScopeTag, const Twine &Name) {
+  assert(Ptr && AddrP && AddrP_Provenance);
+  return CreateGenericNoAliasIntrinsic(
+      Intrinsic::provenance_noalias, Ptr,
+      {NoAliasDecl, AddrP, AddrP_Provenance, ObjId}, {ScopeTag}, {}, Name);
+}
+
+Instruction *IRBuilderBase::CreateProvenanceNoAliasPlain(
+    Value *Ptr, Value *NoAliasDecl, Value *AddrP, Value *AddrP_Provenance,
+    Value *ObjId, Value *ScopeValue, const Twine &Name) {
+  assert(Ptr && AddrP && AddrP_Provenance);
+  return CreateGenericNoAliasIntrinsic(
+      Intrinsic::provenance_noalias, Ptr,
+      {NoAliasDecl, AddrP, AddrP_Provenance, ObjId}, {}, {ScopeValue}, Name);
+}
+
+Instruction *IRBuilderBase::CreateNoAliasArgGuard(Value *Ptr, Value *Provenance,
+                                                  const Twine &Name) {
+  return CreateGenericNoAliasIntrinsic(Intrinsic::noalias_arg_guard, Ptr,
+                                       {Provenance}, {}, {}, Name);
+}
+
+Instruction *
+IRBuilderBase::CreateNoAliasCopyGuard(Value *BasePtr, Value *NoAliasDecl,
+                                      ArrayRef<int64_t> EncodedIndices,
+                                      MDNode *ScopeTag, const Twine &Name) {
+  SmallVector<Metadata *, 10> IndicesArray;
+
+  assert(NoAliasDecl != nullptr);
+  assert(ScopeTag != nullptr);
+  assert(!EncodedIndices.empty() &&
+         "NoAliasCopyGuard should have at least one set of indices");
+
+  for (unsigned i = 0, ci = EncodedIndices.size(); i < ci;) {
+    auto length = EncodedIndices[i++];
+    assert(length > 0 &&
+           "NoAliasCopyGuard: encoded indices problem: zero length seen");
+    length += i;
+    assert(length <= ci &&
+           "NoAliasCopyGuard: encoded indices problem: too few indices");
+
+    SmallVector<Metadata *, 10> Indices;
+    while (i < length) {
+      // Note: getElementPtr requires i32 numbers
+      Indices.push_back(
+          llvm::ConstantAsMetadata::get(getInt32(EncodedIndices[i])));
+      ++i;
+    }
+    IndicesArray.push_back(llvm::MDNode::get(Context, Indices));
+  }
+
+  return CreateGenericNoAliasIntrinsic(
+      Intrinsic::noalias_copy_guard, BasePtr, {NoAliasDecl},
+      {llvm::MDNode::get(Context, IndicesArray), ScopeTag}, {}, Name);
+}
+
+Instruction *IRBuilderBase::CreateGenericNoAliasIntrinsic(
+    Intrinsic::ID ID, Value *Ptr, ArrayRef<Value *> args_opt,
+    ArrayRef<MDNode *> MDNodes, ArrayRef<Value *> MDValues, const Twine &Name) {
+  // FIXME: We can currently mangle just about everything, but not literal
+  // structs (for those, bitcast to i8*).
+  // FIXME: as far as I see in 'getMangledTypeStr', this should be ok now.
+  Value *CPtr = Ptr;
+  if (auto *STyp =
+          dyn_cast<StructType>(CPtr->getType()->getPointerElementType())) {
+    if (STyp->isLiteral())
+      CPtr = getCastedInt8PtrValue(CPtr);
+  }
+
+  SmallVector<Type *, 7> Types = {CPtr->getType()};
+  SmallVector<Value *, 7> Ops = {CPtr};
+  for (auto *A : args_opt) {
+    Types.push_back(A->getType());
+    Ops.push_back(A);
+  }
+  // For the metadata info, types must not be added:
+  for (auto *MD : MDNodes) {
+    Ops.push_back(MetadataAsValue::get(Context, MD));
+  }
+  Ops.insert(Ops.end(), MDValues.begin(), MDValues.end());
+  Module *M = BB->getModule();
+  auto *FnIntrinsic = Intrinsic::getDeclaration(M, ID, Types);
+  Instruction *Ret = createCallHelper(FnIntrinsic, Ops, this, Name);
+
+  if (Ret->getType() != Ptr->getType()) {
+    BitCastInst *BCI = new BitCastInst(Ret, Ptr->getType(), Name + ".cast");
+    BB->getInstList().insert(InsertPt, BCI);
+    SetInstDebugLocation(BCI);
+    Ret = BCI;
+  }
+
+  return Ret;
+}
+
 /// Create a call to a Masked Load intrinsic.
 /// \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
 /// \p Name      - name of the result variable

llvm/lib/IR/Verifier.cpp

case Intrinsic::memset: {
 
     break;
   }
   case Intrinsic::memcpy_element_unordered_atomic:
   case Intrinsic::memmove_element_unordered_atomic:
   case Intrinsic::memset_element_unordered_atomic: {
     const auto *AMI = cast<AtomicMemIntrinsic>(&Call);
 
     ConstantInt *ElementSizeCI =
         cast<ConstantInt>(AMI->getRawElementSizeInBytes());
     const APInt &ElementSizeVal = ElementSizeCI->getValue();
     Assert(ElementSizeVal.isPowerOf2(),
            "element size of the element-wise atomic memory intrinsic "
            "must be a power of 2",
            Call);
 
     auto IsValidAlignment = [&](uint64_t Alignment) {
       return isPowerOf2_64(Alignment) && ElementSizeVal.ule(Alignment);
     };
     uint64_t DstAlignment = AMI->getDestAlignment();
Assert(ResultTy->getElementType() == VecTy->getElementType(),
            "type as the input vector.",
            &Call);
     break;
   }
   case Intrinsic::experimental_noalias_scope_decl: {
     NoAliasScopeDecls.push_back(cast<IntrinsicInst>(&Call));
     break;
   }
+  case Intrinsic::noalias_decl: {
+    Assert(
+        (isa<ConstantPointerNull>(
+             Call.getArgOperand(Intrinsic::NoAliasDeclAllocaArg)) ||
+         isa<AllocaInst>(Call.getArgOperand(Intrinsic::NoAliasDeclAllocaArg))),
+        "llvm.noalias.decl must refer to a null-ptr or an alloca instruction",
+        Call);
+    break;
+  }
+  case Intrinsic::noalias: {
+    auto *DA = Call.getArgOperand(Intrinsic::NoAliasNoAliasDeclArg);
+    if (!isa<ConstantPointerNull>(DA) && !isa<UndefValue>(DA)) {
+      auto *DeclSite = dyn_cast<CallBase>(DA);
+      Assert(DeclSite, "llvm.noalias arg1 must refer to a llvm.noalias.decl",
+             Call);
+      Assert((DeclSite->getArgOperand(Intrinsic::NoAliasDeclObjIdArg) ==
+              Call.getArgOperand(Intrinsic::NoAliasIdentifyPObjIdArg)),
+             "llvm.noalias objId arg must match with llvm.noalias.decl", Call);
+      Assert((DeclSite->getArgOperand(Intrinsic::NoAliasDeclScopeArg) ==
+              Call.getArgOperand(Intrinsic::NoAliasScopeArg)),
+             "llvm.noalias scope arg must match with llvm.noalias.decl", Call);
+    }
+    break;
+  }
+  case Intrinsic::provenance_noalias: {
+    auto *DA = Call.getArgOperand(Intrinsic::ProvenanceNoAliasNoAliasDeclArg);
+    if (!isa<ConstantPointerNull>(DA) && !isa<UndefValue>(DA)) {
+      // JumpThreading can duplicate llvm.noalias.decl.
+      // I do not think we should prohibit that.
+      SmallVector<CallBase *, 4> NoAliasDeclarations;
+      {
+        DenseSet<Value *> Handled;
+        SmallVector<Value *, 4> Worklist = {DA};
+        while (!Worklist.empty()) {
+          auto *V = Worklist.pop_back_val();
+          if (Handled.insert(V).second) {
+            if (isa<CallBase>(V)) {
+              NoAliasDeclarations.push_back(cast<CallBase>(V));
+            } else if (PHINode *PHI = dyn_cast<PHINode>(V)) {
+              auto OV = PHI->operand_values();
+              Worklist.insert(Worklist.end(), OV.begin(), OV.end());
+            } else if (isa<UndefValue>(V)) {
+              // ignore undefs
+            } else if (isa<ConstantPointerNull>(V)) {
+              // ignore nullptr
+            } else {
+              Assert(
+                  false,
+                  "llvm.provenance.noalias depends on something that is not a "
+                  "llvm.noalias.decl",
+                  Call);
+            }
+          }
+        }
+      }
+
+      Assert(!NoAliasDeclarations.empty(),
+             "llvm.provenance.noalias should depend on a llvm.noalias.decl",
+             Call);
+      for (auto *CB : NoAliasDeclarations) {
+        Assert(CB,
+               "llvm.provenance.noalias arg1 must refer to a llvm.noalias.decl",
+               Call);
+        Assert(CB->getIntrinsicID() == Intrinsic::noalias_decl,
+               "llvm.provenance.noalias arg1 must refer to a llvm.noalias.decl",
+               Call);
+        Assert(
+            (CB->getArgOperand(Intrinsic::NoAliasDeclObjIdArg) ==
+             Call.getArgOperand(Intrinsic::ProvenanceNoAliasIdentifyPObjIdArg)),
+            "llvm.provenance.noalias objId arg must match with "
+            "llvm.noalias.decl",
+            Call);
+        Assert((CB->getArgOperand(Intrinsic::NoAliasDeclScopeArg) ==
+                Call.getArgOperand(Intrinsic::ProvenanceNoAliasScopeArg)),
+               "llvm.provenance.noalias scope arg must match with "
+               "llvm.noalias.decl",
+               Call);
+      }
+    }
+    break;
+  }
   };
 }
 
 /// Carefully grab the subprogram from a local scope.
 ///
 /// This carefully grabs the subprogram from a local scope, avoiding the
 /// built-in assertions that would typically fire.
 static DISubprogram *getSubprogram(Metadata *LocalScope) {

llvm/unittests/IR/IRBuilderTest.cpp

 //===- llvm/unittest/IR/IRBuilderTest.cpp - IRBuilder tests ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IntrinsicsAArch64.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/NoFolder.h"
 #include "llvm/IR/Verifier.h"
 #include "gtest/gtest.h"
 
TEST_F(IRBuilderTest, ConstrainedFPFunctionCall) {
   // Check the attributes to verify the strictfp attribute is on the call.
   EXPECT_TRUE(FCall->getAttributes().getFnAttributes().hasAttribute(
       Attribute::StrictFP));
 
   Builder.CreateRetVoid();
   EXPECT_FALSE(verifyModule(*M));
 }
 
+TEST_F(IRBuilderTest, NoAlias) {
+  IRBuilder<> Builder(BB);
+  AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
+
+  AllocaInst *VarP = Builder.CreateAlloca(Builder.getInt8PtrTy());
+  Builder.CreateStore(Var1, VarP);
+
+  MDBuilder MDB(BB->getContext());
+  MDNode *NewDomain = MDB.createAnonymousAliasScopeDomain("Test Domain");
+  MDNode *AScope = MDB.createAnonymousAliasScope(NewDomain, "Test Scope");
+
+  CallInst *NAD =
+      cast<CallInst>(Builder.CreateNoAliasDeclaration(VarP, AScope));
+  Value *Pointer = Builder.CreateLoad(Builder.getInt8PtrTy(), VarP);
+  CallInst *NAP =
+      cast<CallInst>(Builder.CreateNoAliasPointer(Pointer, NAD, VarP, AScope));
+
+  // llvm.noalias.decl
+  EXPECT_EQ(NAD->getArgOperand(Intrinsic::NoAliasDeclAllocaArg), VarP);
+  EXPECT_EQ(
+      cast<ConstantInt>(NAD->getArgOperand(Intrinsic::NoAliasDeclObjIdArg))
+          ->getZExtValue(),
+      0ull);
+  EXPECT_EQ(
+      cast<MetadataAsValue>(NAD->getArgOperand(Intrinsic::NoAliasDeclScopeArg))
+          ->getMetadata(),
+      AScope);
+
+  IntrinsicInst *II_NAD = dyn_cast<IntrinsicInst>(NAD);
+  ASSERT_TRUE(II_NAD != nullptr);
+  EXPECT_EQ(II_NAD->getIntrinsicID(), Intrinsic::noalias_decl);
+
+  EXPECT_TRUE(NAD->onlyAccessesInaccessibleMemory());
+  EXPECT_TRUE(NAD->doesNotThrow());
+
+  // llvm.noalias
+  EXPECT_EQ(NAP->getArgOperand(0), Pointer);
+  EXPECT_EQ(NAP->getArgOperand(Intrinsic::NoAliasNoAliasDeclArg), NAD);
+  EXPECT_EQ(NAP->getArgOperand(Intrinsic::NoAliasIdentifyPArg), VarP);
+  EXPECT_EQ(
+      cast<MetadataAsValue>(NAP->getArgOperand(Intrinsic::NoAliasScopeArg))
+          ->getMetadata(),
+      AScope);
+  EXPECT_EQ(
+      cast<ConstantInt>(NAP->getArgOperand(Intrinsic::NoAliasIdentifyPObjIdArg))
+          ->getZExtValue(),
+      0ull); // default object id is 0
+
+  IntrinsicInst *II_NAP = dyn_cast<IntrinsicInst>(NAP);
+  ASSERT_TRUE(II_NAP != nullptr);
+  EXPECT_EQ(II_NAP->getIntrinsicID(), Intrinsic::noalias);
+
+  EXPECT_TRUE(NAP->onlyAccessesArgMemory());
+  EXPECT_TRUE(NAP->doesNotThrow());
+}
+
+TEST_F(IRBuilderTest, ProvenanceNoAliasAndArgGuard) {
+  IRBuilder<> Builder(BB);
+  AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
+
+  AllocaInst *VarP = Builder.CreateAlloca(Builder.getInt8PtrTy());
+  Builder.CreateStore(Var1, VarP);
+
+  MDBuilder MDB(BB->getContext());
+  MDNode *NewDomain = MDB.createAnonymousAliasScopeDomain("Test Domain");
+  MDNode *AScope = MDB.createAnonymousAliasScope(NewDomain, "Test Scope");
+
+  CallInst *NAD =
+      cast<CallInst>(Builder.CreateNoAliasDeclaration(VarP, AScope));
+  Value *Pointer = Builder.CreateLoad(Builder.getInt8PtrTy(), VarP);
+  CallInst *SNAP = cast<CallInst>(Builder.CreateProvenanceNoAliasPlain(
+      Pointer, NAD, VarP, llvm::ConstantPointerNull::get(VarP->getType()),
+      NAD->getArgOperand(Intrinsic::NoAliasDeclObjIdArg), AScope));
+
+  CallInst *NAG = cast<CallInst>(Builder.CreateNoAliasArgGuard(Pointer, SNAP));
+
+  // create load on Pointer, with SNAP provenance
+
+  // llvm.provenance.noalias
+  EXPECT_EQ(SNAP->getArgOperand(0), Pointer);
+  EXPECT_EQ(SNAP->getArgOperand(Intrinsic::ProvenanceNoAliasNoAliasDeclArg),
+            NAD);
+  EXPECT_EQ(SNAP->getArgOperand(Intrinsic::ProvenanceNoAliasIdentifyPArg),
+            VarP);
+  EXPECT_EQ(cast<MetadataAsValue>(
+                SNAP->getArgOperand(Intrinsic::ProvenanceNoAliasScopeArg))
+                ->getMetadata(),
+            AScope);
+  ASSERT_TRUE(cast<ConstantPointerNull>(
+      SNAP->getArgOperand(Intrinsic::ProvenanceNoAliasIdentifyPProvenanceArg)));
+  EXPECT_EQ(
+      cast<ConstantInt>(
+          SNAP->getArgOperand(Intrinsic::ProvenanceNoAliasIdentifyPObjIdArg))
+          ->getZExtValue(),
+      0ull); // default object id is 0
+
+  IntrinsicInst *II_SNAP = dyn_cast<IntrinsicInst>(SNAP);
+  ASSERT_TRUE(II_SNAP != nullptr);
+  EXPECT_EQ(II_SNAP->getIntrinsicID(), Intrinsic::provenance_noalias);
+
+  EXPECT_TRUE(SNAP->doesNotAccessMemory());
+  EXPECT_TRUE(SNAP->doesNotThrow());
+
+  // llvm.noalias.arg.guard
+  EXPECT_EQ(NAG->getArgOperand(0), Pointer);
+  EXPECT_EQ(NAG->getArgOperand(1), SNAP);
+
+  EXPECT_TRUE(NAG->doesNotAccessMemory());
+  EXPECT_TRUE(NAG->doesNotThrow());
+}
+
+TEST_F(IRBuilderTest, NoAliasCopyGuard) {
+  // // roughly equivalent code for:
+  // struct FOO { char* __reststrict p; }
+  // char copy_restrict(struct FOO* p) {
+  //   struct FOO local=*p; // Introduces llvm.noalias.copy.guard
+  //   return *local.p; // NOTE: this part is omitted
+  //  }
+
+  IRBuilder<> Builder(BB);
+  StructType *ST =
+      StructType::create(BB->getContext(), {Builder.getInt8PtrTy()});
+
+  // pointer to incoming struct
+  AllocaInst *VarIn = Builder.CreateAlloca(ST->getPointerTo());
+
+  // local struct
+  AllocaInst *Var1 = Builder.CreateAlloca(ST);
+  // pointer to local struct
+  AllocaInst *VarP = Builder.CreateAlloca(ST->getPointerTo());
+  Builder.CreateStore(Var1, VarP);
+
+  MDBuilder MDB(BB->getContext());
+  MDNode *NewDomain = MDB.createAnonymousAliasScopeDomain("Test Domain");
+  MDNode *AScope = MDB.createAnonymousAliasScope(NewDomain, "Test Scope");
+
+  CallInst *NAD =
+      cast<CallInst>(Builder.CreateNoAliasDeclaration(VarP, AScope));
+  (void)NAD; // not used as we don't do the 'return *local.p' here
+
+  auto *SrcPointer = Builder.CreateLoad(ST->getPointerTo(), VarIn);
+  // one entry of length 2, containing {-1, 0} :
+  const int64_t Indices[] = {2, -1, 0};
+  auto Int8PtrNull = ConstantPointerNull::get(Builder.getInt8PtrTy());
+  CallInst *GP = cast<CallInst>(Builder.CreateNoAliasCopyGuard(
+      SrcPointer,
+      Int8PtrNull, // out-of-function __restrict declaration
+      Indices, // For struct FOO* f, all f[X].p (X ~ -1, .p ~ 0) are restrict
+      AScope));
+  auto *Copy = Builder.CreateMemCpy(
+      Var1, Align(4), GP, Align(4),
+      BB->getParent()->getParent()->getDataLayout().getTypeStoreSize(ST));
+  (void)Copy;
+
+  // llvm.provenance.noalias
+  EXPECT_EQ(GP->getArgOperand(Intrinsic::NoAliasCopyGuardIdentifyPBaseObject),
+            SrcPointer);
+  EXPECT_EQ(GP->getArgOperand(Intrinsic::NoAliasCopyGuardNoAliasDeclArg),
+            Int8PtrNull);
+
+  // hmm. how to easily check that we are pointing to a { { -1, 0 } } array ?
+  EXPECT_TRUE(cast<MetadataAsValue>(GP->getArgOperand(
+                  Intrinsic::NoAliasCopyGuardIndicesArg)) != nullptr);
+  EXPECT_EQ(cast<MetadataAsValue>(
+                GP->getArgOperand(Intrinsic::NoAliasCopyGuardScopeArg))
+                ->getMetadata(),
+            AScope);
+
+  EXPECT_TRUE(GP->doesNotAccessMemory());
+  EXPECT_TRUE(GP->doesNotThrow());
+}
+
 TEST_F(IRBuilderTest, Provenance) {
   IRBuilder<> Builder(BB);
 
   auto *L = Builder.CreateLoad(GV->getValueType(), GV);
   EXPECT_TRUE(!L->hasNoaliasProvenanceOperand());
 
   auto *S = Builder.CreateStore(L, GV);
   EXPECT_TRUE(!S->hasNoaliasProvenanceOperand());