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 } 404
