llvm.noalias - Add IRBuilder support

[hfinkel]

Summary

This is part of the series started by D9375, and adds functions in IRBuilder to create the llvm.noalias intrinsics (this is used by later patches).

There is a workaround for some kinds of pointers we can't currently mangle. I don't think this is worth fixing in the mangling code because soon we'll have only an opaque pointer type and this will be irrelevant.

[reames]

include/llvm/IR/IRBuilder.h

472

CreateNoAlias sounds confusing. Maybe, CreateNoAliasMarker? CreateNoAliasIntrinsic?

lib/IR/IRBuilder.cpp

206

I would rather see you just bitcast everything. Having one weird special case when we're moving to unified pointers anyways seems unjustified.

Very minor preference here; feel free to ignore.

217

Use getModule

220

If the original pointer is noalias, should the return also be noalias? I note that this is a different noalias per discussion on another thread. Slightly confusing to say the least.

Other attributes: nonnull, dereferenceable, etc..? I'd be fine with instcombine rules instead.

224

Using BitCastInst::Create might simplify these two lines.

[reames]

Resigning as a reviewer to get a very stale review off my list of blocking tasks in phabricator. Please reopen when desired.

[hfinkel]

include/llvm/IR/IRBuilder.h

472

None of the other functions that create intrinsics have 'Intrinsic' in name, and so it seems weird to do it for this one. The best I can think of is 'CreateNoAliasPointer'.

lib/IR/IRBuilder.cpp

224

There is no such function (and the InsertPt variable is not an Instruction*, but a BB iterator ).

[hfinkel]

Rebased, the function name was changed in response to Philip's feedback, and a unit test was added.

[majnemer]

lib/IR/IRBuilder.cpp

209

auto *STy

[hfinkel]

Rebased (and addressed reviewer feedback).

[hfinkel]

Ping.

[hfinkel]

Rebased.

include/llvm/IR/IRBuilder.h

public:
   /// \brief Create a call to Masked Scatter intrinsic
   CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Align,
                                 Value *Mask = nullptr);
 
   /// \brief Create an assume intrinsic call that allows the optimizer to
   /// assume that the provided condition will be true.
   CallInst *CreateAssumption(Value *Cond);
 
+  /// \brief Create an noalias intrinsic.
+  Instruction *CreateNoAliasPointer(Value *Ptr, MDNode *ScopeTag);
+
   /// \brief 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,
                                    ArrayRef<Value *> DeoptArgs,
                                    ArrayRef<Value *> GCArgs,
                                    const Twine &Name = "");

lib/IR/IRBuilder.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/IR/Statepoint.h"
 using namespace llvm;
 
 /// CreateGlobalString - Make a new global variable with an initializer that
 /// has array of i8 type filled in with the nul terminated string value
 /// specified.  If Name is specified, it is the name of the global variable
 /// created.
 GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str,
assert(Cond->getType() == getInt1Ty() &&
          "an assumption condition must be of type i1");
 
   Value *Ops[] = { Cond };
   Module *M = BB->getParent()->getParent();
   Value *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume);
   return createCallHelper(FnAssume, Ops, this);
 }
 
+Instruction *IRBuilderBase::CreateNoAliasPointer(Value *Ptr, MDNode *ScopeTag) {
+  // FIXME: We can currently mangle just about everything, but not literal
+  // structs (for those, bitcast to i8*).
+  Value *CPtr = Ptr;
+  if (StructType* STyp =
+        dyn_cast<StructType>(CPtr->getType()->getPointerElementType())) {
+    if (STyp->isLiteral())
+      CPtr = getCastedInt8PtrValue(CPtr);
+  }
+
+  Type *Types[] = { CPtr->getType() };
+  Value *Ops[] = { CPtr, MetadataAsValue::get(Context, ScopeTag) };
+  Module *M = BB->getModule();
+  Value *FnNoAlias = Intrinsic::getDeclaration(M, Intrinsic::noalias, Types);
+  Instruction *Ret = createCallHelper(FnNoAlias, Ops, this);
+
+  if (Ret->getType() != Ptr->getType()) {
+    BitCastInst *BCI = new BitCastInst(Ret, Ptr->getType(), "");
+    BB->getInstList().insert(InsertPt, BCI);
+    SetInstDebugLocation(BCI);
+    Ret = BCI;
+  }
+
+  return Ret;
+}
+
 /// \brief Create a call to a Masked Load intrinsic.
 /// \p Ptr      - base pointer for the load
 /// \p Align    - 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

unittests/IR/IRBuilderTest.cpp

protected:
 
   LLVMContext Ctx;
   std::unique_ptr<Module> M;
   Function *F;
   BasicBlock *BB;
   GlobalVariable *GV;
 };
 
+TEST_F(IRBuilderTest, NoAlias) {
+  IRBuilder<> Builder(BB);
+  AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
+
+  MDBuilder MDB(BB->getContext());
+  MDNode *NewDomain =
+    MDB.createAnonymousAliasScopeDomain("Test Domain");
+  MDNode *AScope =
+    MDB.createAnonymousAliasScope(NewDomain, "Test Scope");
+
+  CallInst *NAP = cast<CallInst>(Builder.CreateNoAliasPointer(Var1, AScope));
+
+  EXPECT_EQ(NAP->getArgOperand(0), Var1);
+  EXPECT_EQ(cast<MetadataAsValue>(NAP->getArgOperand(1))->getMetadata(),
+            AScope);
+
+  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, 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);