lib/IR/IRBuilder.cpp

   1 //===---- IRBuilder.cpp - Builder for LLVM Instrs -------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the IRBuilder class, which is used as a convenient way
  11 // to create LLVM instructions with a consistent and simplified interface.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/IR/Function.h"
  16 #include "llvm/IR/GlobalVariable.h"
  17 #include "llvm/IR/IRBuilder.h"
  18 #include "llvm/IR/Intrinsics.h"
  19 #include "llvm/IR/LLVMContext.h"
  20 #include "llvm/IR/Statepoint.h"
  21 using namespace llvm;
  22
  23 /// CreateGlobalString - Make a new global variable with an initializer that
  24 /// has array of i8 type filled in with the nul terminated string value
  25 /// specified.  If Name is specified, it is the name of the global variable
  26 /// created.
  27 GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str,
  28                                                   const Twine &Name,
  29                                                   unsigned AddressSpace) {
  30   Constant *StrConstant = ConstantDataArray::getString(Context, Str);
  31   Module &M = *BB->getParent()->getParent();
  32   GlobalVariable *GV = new GlobalVariable(M, StrConstant->getType(),
  33                                           true, GlobalValue::PrivateLinkage,
  34                                           StrConstant, Name, nullptr,
  35                                           GlobalVariable::NotThreadLocal,
  36                                           AddressSpace);
  37   GV->setUnnamedAddr(true);
  38   return GV;
  39 }
  40
  41 Type *IRBuilderBase::getCurrentFunctionReturnType() const {
  42   assert(BB && BB->getParent() && "No current function!");
  43   return BB->getParent()->getReturnType();
  44 }
  45
  46 Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) {
  47   PointerType *PT = cast<PointerType>(Ptr->getType());
  48   if (PT->getElementType()->isIntegerTy(8))
  49     return Ptr;
  50
  51   // Otherwise, we need to insert a bitcast.
  52   PT = getInt8PtrTy(PT->getAddressSpace());
  53   BitCastInst *BCI = new BitCastInst(Ptr, PT, "");
  54   BB->getInstList().insert(InsertPt, BCI);
  55   SetInstDebugLocation(BCI);
  56   return BCI;
  57 }
  58
  59 static CallInst *createCallHelper(Value *Callee, ArrayRef<Value *> Ops,
  60                                   IRBuilderBase *Builder,
  61                                   const Twine& Name="") {
  62   CallInst *CI = CallInst::Create(Callee, Ops, Name);
  63   Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),CI);
  64   Builder->SetInstDebugLocation(CI);
  65   return CI;
  66 }
  67
  68 static InvokeInst *createInvokeHelper(Value *Invokee, BasicBlock *NormalDest,
  69                                       BasicBlock *UnwindDest,
  70                                       ArrayRef<Value *> Ops,
  71                                       IRBuilderBase *Builder,
  72                                       const Twine &Name = "") {
  73   InvokeInst *II =
  74       InvokeInst::Create(Invokee, NormalDest, UnwindDest, Ops, Name);
  75   Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),
  76                                                   II);
  77   Builder->SetInstDebugLocation(II);
  78   return II;
  79 }
  80
  81 CallInst *IRBuilderBase::
  82 CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
  83              bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
  84              MDNode *NoAliasTag) {
  85   Ptr = getCastedInt8PtrValue(Ptr);
  86   Value *Ops[] = { Ptr, Val, Size, getInt32(Align), getInt1(isVolatile) };
  87   Type *Tys[] = { Ptr->getType(), Size->getType() };
  88   Module *M = BB->getParent()->getParent();
  89   Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
  90
  91   CallInst *CI = createCallHelper(TheFn, Ops, this);
  92
  93   // Set the TBAA info if present.
  94   if (TBAATag)
  95     CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
  96
  97   if (ScopeTag)
  98     CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
  99
 100   if (NoAliasTag)
 101     CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
 102
 103   return CI;
 104 }
 105
 106 CallInst *IRBuilderBase::
 107 CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align,
 108              bool isVolatile, MDNode *TBAATag, MDNode *TBAAStructTag,
 109              MDNode *ScopeTag, MDNode *NoAliasTag) {
 110   Dst = getCastedInt8PtrValue(Dst);
 111   Src = getCastedInt8PtrValue(Src);
 112
 113   Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) };
 114   Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
 115   Module *M = BB->getParent()->getParent();
 116   Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys);
 117
 118   CallInst *CI = createCallHelper(TheFn, Ops, this);
 119
 120   // Set the TBAA info if present.
 121   if (TBAATag)
 122     CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
 123
 124   // Set the TBAA Struct info if present.
 125   if (TBAAStructTag)
 126     CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
 127
 128   if (ScopeTag)
 129     CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
 130
 131   if (NoAliasTag)
 132     CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
 133
 134   return CI;
 135 }
 136
 137 CallInst *IRBuilderBase::
 138 CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align,
 139               bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag,
 140               MDNode *NoAliasTag) {
 141   Dst = getCastedInt8PtrValue(Dst);
 142   Src = getCastedInt8PtrValue(Src);
 143
 144   Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) };
 145   Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
 146   Module *M = BB->getParent()->getParent();
 147   Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys);
 148
 149   CallInst *CI = createCallHelper(TheFn, Ops, this);
 150
 151   // Set the TBAA info if present.
 152   if (TBAATag)
 153     CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
 154
 155   if (ScopeTag)
 156     CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
 157
 158   if (NoAliasTag)
 159     CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
 160
 161   return CI;
 162 }
 163
 164 CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
 165   assert(isa<PointerType>(Ptr->getType()) &&
 166          "lifetime.start only applies to pointers.");
 167   Ptr = getCastedInt8PtrValue(Ptr);
 168   if (!Size)
 169     Size = getInt64(-1);
 170   else
 171     assert(Size->getType() == getInt64Ty() &&
 172            "lifetime.start requires the size to be an i64");
 173   Value *Ops[] = { Size, Ptr };
 174   Module *M = BB->getParent()->getParent();
 175   Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start);
 176   return createCallHelper(TheFn, Ops, this);
 177 }
 178
 179 CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
 180   assert(isa<PointerType>(Ptr->getType()) &&
 181          "lifetime.end only applies to pointers.");
 182   Ptr = getCastedInt8PtrValue(Ptr);
 183   if (!Size)
 184     Size = getInt64(-1);
 185   else
 186     assert(Size->getType() == getInt64Ty() &&
 187            "lifetime.end requires the size to be an i64");
 188   Value *Ops[] = { Size, Ptr };
 189   Module *M = BB->getParent()->getParent();
 190   Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end);
 191   return createCallHelper(TheFn, Ops, this);
 192 }
 193
 194 CallInst *IRBuilderBase::CreateAssumption(Value *Cond) {
 195   assert(Cond->getType() == getInt1Ty() &&
 196          "an assumption condition must be of type i1");
 197
 198   Value *Ops[] = { Cond };
 199   Module *M = BB->getParent()->getParent();
 200   Value *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume);
 201   return createCallHelper(FnAssume, Ops, this);
 202 }
 203
 204 /// Create a call to a Masked Load intrinsic.
 205 /// Ptr      - the base pointer for the load
 206 /// Align    - alignment of the source location
 207 /// Mask     - an vector of booleans which indicates what vector lanes should
 208 ///            be accessed in memory
 209 /// PassThru - a pass-through value that is used to fill the masked-off lanes
 210 ///            of the result
 211 /// Name     - name of the result variable
 212 CallInst *IRBuilderBase::CreateMaskedLoad(Value *Ptr, unsigned Align,
 213                                           Value *Mask, Value *PassThru,
 214                                           const Twine &Name) {
 215   assert(Ptr->getType()->isPointerTy() && "Ptr must be of pointer type");
 216   // DataTy is the overloaded type
 217   Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
 218   assert(DataTy->isVectorTy() && "Ptr should point to a vector");
 219   if (!PassThru)
 220     PassThru = UndefValue::get(DataTy);
 221   Value *Ops[] = { Ptr, getInt32(Align), Mask,  PassThru};
 222   return CreateMaskedIntrinsic(Intrinsic::masked_load, Ops, DataTy, Name);
 223 }
 224
 225 /// Create a call to a Masked Store intrinsic.
 226 /// Val   - the data to be stored,
 227 /// Ptr   - the base pointer for the store
 228 /// Align - alignment of the destination location
 229 /// Mask  - an vector of booleans which indicates what vector lanes should
 230 ///         be accessed in memory
 231 CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr,
 232                                            unsigned Align, Value *Mask) {
 233   Value *Ops[] = { Val, Ptr, getInt32(Align), Mask };
 234   // Type of the data to be stored - the only one overloaded type
 235   return CreateMaskedIntrinsic(Intrinsic::masked_store, Ops, Val->getType());
 236 }
 237
 238 /// Create a call to a Masked intrinsic, with given intrinsic Id,
 239 /// an array of operands - Ops, and one overloaded type - DataTy
 240 CallInst *IRBuilderBase::CreateMaskedIntrinsic(Intrinsic::ID Id,
 241                                                ArrayRef<Value *> Ops,
 242                                                Type *DataTy,
 243                                                const Twine &Name) {
 244   Module *M = BB->getParent()->getParent();
 245   Type *OverloadedTypes[] = { DataTy };
 246   Value *TheFn = Intrinsic::getDeclaration(M, Id, OverloadedTypes);
 247   return createCallHelper(TheFn, Ops, this, Name);
 248 }
 249
 250 template <typename T0, typename T1, typename T2, typename T3>
 251 static std::vector<Value *>
 252 getStatepointArgs(IRBuilderBase &B, uint64_t ID, uint32_t NumPatchBytes,
 253                   Value *ActualCallee, uint32_t Flags, ArrayRef<T0> CallArgs,
 254                   ArrayRef<T1> TransitionArgs, ArrayRef<T2> DeoptArgs,
 255                   ArrayRef<T3> GCArgs) {
 256   std::vector<Value *> Args;
 257   Args.push_back(B.getInt64(ID));
 258   Args.push_back(B.getInt32(NumPatchBytes));
 259   Args.push_back(ActualCallee);
 260   Args.push_back(B.getInt32(CallArgs.size()));
 261   Args.push_back(B.getInt32(Flags));
 262   Args.insert(Args.end(), CallArgs.begin(), CallArgs.end());
 263   Args.push_back(B.getInt32(TransitionArgs.size()));
 264   Args.insert(Args.end(), TransitionArgs.begin(), TransitionArgs.end());
 265   Args.push_back(B.getInt32(DeoptArgs.size()));
 266   Args.insert(Args.end(), DeoptArgs.begin(), DeoptArgs.end());
 267   Args.insert(Args.end(), GCArgs.begin(), GCArgs.end());
 268
 269   return Args;
 270 }
 271
 272 template <typename T0, typename T1, typename T2, typename T3>
 273 static CallInst *CreateGCStatepointCallCommon(
 274     IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes,
 275     Value *ActualCallee, uint32_t Flags, ArrayRef<T0> CallArgs,
 276     ArrayRef<T1> TransitionArgs, ArrayRef<T2> DeoptArgs, ArrayRef<T3> GCArgs,
 277     const Twine &Name) {
 278   // Extract out the type of the callee.
 279   PointerType *FuncPtrType = cast<PointerType>(ActualCallee->getType());
 280   assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
 281          "actual callee must be a callable value");
 282
 283   Module *M = Builder->GetInsertBlock()->getParent()->getParent();
 284   // Fill in the one generic type'd argument (the function is also vararg)
 285   Type *ArgTypes[] = { FuncPtrType };
 286   Function *FnStatepoint =
 287     Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_statepoint,
 288                               ArgTypes);
 289
 290   std::vector<llvm::Value *> Args =
 291       getStatepointArgs(*Builder, ID, NumPatchBytes, ActualCallee, Flags,
 292                         CallArgs, TransitionArgs, DeoptArgs, GCArgs);
 293   return createCallHelper(FnStatepoint, Args, Builder, Name);
 294 }
 295
 296 CallInst *IRBuilderBase::CreateGCStatepointCall(
 297     uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
 298     ArrayRef<Value *> CallArgs, ArrayRef<Value *> DeoptArgs,
 299     ArrayRef<Value *> GCArgs, const Twine &Name) {
 300   return CreateGCStatepointCallCommon<Value *, Value *, Value *, Value *>(
 301       this, ID, NumPatchBytes, ActualCallee, uint32_t(StatepointFlags::None),
 302       CallArgs, None /* No Transition Args */, DeoptArgs, GCArgs, Name);
 303 }
 304
 305 CallInst *IRBuilderBase::CreateGCStatepointCall(
 306     uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee, uint32_t Flags,
 307     ArrayRef<Use> CallArgs, ArrayRef<Use> TransitionArgs,
 308     ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
 309   return CreateGCStatepointCallCommon<Use, Use, Use, Value *>(
 310       this, ID, NumPatchBytes, ActualCallee, Flags, CallArgs, TransitionArgs,
 311       DeoptArgs, GCArgs, Name);
 312 }
 313
 314 CallInst *IRBuilderBase::CreateGCStatepointCall(
 315     uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
 316     ArrayRef<Use> CallArgs, ArrayRef<Value *> DeoptArgs,
 317     ArrayRef<Value *> GCArgs, const Twine &Name) {
 318   return CreateGCStatepointCallCommon<Use, Value *, Value *, Value *>(
 319       this, ID, NumPatchBytes, ActualCallee, uint32_t(StatepointFlags::None),
 320       CallArgs, None, DeoptArgs, GCArgs, Name);
 321 }
 322
 323 template <typename T0, typename T1, typename T2, typename T3>
 324 static InvokeInst *CreateGCStatepointInvokeCommon(
 325     IRBuilderBase *Builder, uint64_t ID, uint32_t NumPatchBytes,
 326     Value *ActualInvokee, BasicBlock *NormalDest, BasicBlock *UnwindDest,
 327     uint32_t Flags, ArrayRef<T0> InvokeArgs, ArrayRef<T1> TransitionArgs,
 328     ArrayRef<T2> DeoptArgs, ArrayRef<T3> GCArgs, const Twine &Name) {
 329   // Extract out the type of the callee.
 330   PointerType *FuncPtrType = cast<PointerType>(ActualInvokee->getType());
 331   assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
 332          "actual callee must be a callable value");
 333
 334   Module *M = Builder->GetInsertBlock()->getParent()->getParent();
 335   // Fill in the one generic type'd argument (the function is also vararg)
 336   Function *FnStatepoint = Intrinsic::getDeclaration(
 337       M, Intrinsic::experimental_gc_statepoint, {FuncPtrType});
 338
 339   std::vector<llvm::Value *> Args =
 340       getStatepointArgs(*Builder, ID, NumPatchBytes, ActualInvokee, Flags,
 341                         InvokeArgs, TransitionArgs, DeoptArgs, GCArgs);
 342   return createInvokeHelper(FnStatepoint, NormalDest, UnwindDest, Args, Builder,
 343                             Name);
 344 }
 345
 346 InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
 347     uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
 348     BasicBlock *NormalDest, BasicBlock *UnwindDest,
 349     ArrayRef<Value *> InvokeArgs, ArrayRef<Value *> DeoptArgs,
 350     ArrayRef<Value *> GCArgs, const Twine &Name) {
 351   return CreateGCStatepointInvokeCommon<Value *, Value *, Value *, Value *>(
 352       this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
 353       uint32_t(StatepointFlags::None), InvokeArgs, None /* No Transition Args*/,
 354       DeoptArgs, GCArgs, Name);
 355 }
 356
 357 InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
 358     uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
 359     BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
 360     ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
 361     ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
 362   return CreateGCStatepointInvokeCommon<Use, Use, Use, Value *>(
 363       this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest, Flags,
 364       InvokeArgs, TransitionArgs, DeoptArgs, GCArgs, Name);
 365 }
 366
 367 InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
 368     uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
 369     BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
 370     ArrayRef<Value *> DeoptArgs, ArrayRef<Value *> GCArgs, const Twine &Name) {
 371   return CreateGCStatepointInvokeCommon<Use, Value *, Value *, Value *>(
 372       this, ID, NumPatchBytes, ActualInvokee, NormalDest, UnwindDest,
 373       uint32_t(StatepointFlags::None), InvokeArgs, None, DeoptArgs, GCArgs,
 374       Name);
 375 }
 376
 377 CallInst *IRBuilderBase::CreateGCResult(Instruction *Statepoint,
 378                                        Type *ResultType,
 379                                        const Twine &Name) {
 380  Intrinsic::ID ID = Intrinsic::experimental_gc_result;
 381  Module *M = BB->getParent()->getParent();
 382  Type *Types[] = {ResultType};
 383  Value *FnGCResult = Intrinsic::getDeclaration(M, ID, Types);
 384
 385  Value *Args[] = {Statepoint};
 386  return createCallHelper(FnGCResult, Args, this, Name);
 387 }
 388
 389 CallInst *IRBuilderBase::CreateGCRelocate(Instruction *Statepoint,
 390                                          int BaseOffset,
 391                                          int DerivedOffset,
 392                                          Type *ResultType,
 393                                          const Twine &Name) {
 394  Module *M = BB->getParent()->getParent();
 395  Type *Types[] = {ResultType};
 396  Value *FnGCRelocate =
 397    Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_relocate, Types);
 398
 399  Value *Args[] = {Statepoint,
 400                   getInt32(BaseOffset),
 401                   getInt32(DerivedOffset)};
 402  return createCallHelper(FnGCRelocate, Args, this, Name);
 403 }