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 using namespace llvm; 21 22 /// CreateGlobalString - Make a new global variable with an initializer that 23 /// has array of i8 type filled in with the nul terminated string value 24 /// specified. If Name is specified, it is the name of the global variable 25 /// created. 26 GlobalVariable *IRBuilderBase::CreateGlobalString(StringRef Str, 27 const Twine &Name) { 28 Constant *StrConstant = ConstantDataArray::getString(Context, Str); 29 Module &M = *BB->getParent()->getParent(); 30 GlobalVariable *GV = new GlobalVariable(M, StrConstant->getType(), 31 true, GlobalValue::PrivateLinkage, 32 StrConstant); 33 GV->setName(Name); 34 GV->setUnnamedAddr(true); 35 return GV; 36 } 37 38 Type *IRBuilderBase::getCurrentFunctionReturnType() const { 39 assert(BB && BB->getParent() && "No current function!"); 40 return BB->getParent()->getReturnType(); 41 } 42 43 Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) { 44 PointerType *PT = cast<PointerType>(Ptr->getType()); 45 if (PT->getElementType()->isIntegerTy(8)) 46 return Ptr; 47 48 // Otherwise, we need to insert a bitcast. 49 PT = getInt8PtrTy(PT->getAddressSpace()); 50 BitCastInst *BCI = new BitCastInst(Ptr, PT, ""); 51 BB->getInstList().insert(InsertPt, BCI); 52 SetInstDebugLocation(BCI); 53 return BCI; 54 } 55 56 static CallInst *createCallHelper(Value *Callee, ArrayRef<Value *> Ops, 57 IRBuilderBase *Builder, 58 const Twine& Name="") { 59 CallInst *CI = CallInst::Create(Callee, Ops, Name); 60 Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),CI); 61 Builder->SetInstDebugLocation(CI); 62 return CI; 63 } 64 65 CallInst *IRBuilderBase:: 66 CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align, 67 bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag, 68 MDNode *NoAliasTag) { 69 Ptr = getCastedInt8PtrValue(Ptr); 70 Value *Ops[] = { Ptr, Val, Size, getInt32(Align), getInt1(isVolatile) }; 71 Type *Tys[] = { Ptr->getType(), Size->getType() }; 72 Module *M = BB->getParent()->getParent(); 73 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys); 74 75 CallInst *CI = createCallHelper(TheFn, Ops, this); 76 77 // Set the TBAA info if present. 78 if (TBAATag) 79 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); 80 81 if (ScopeTag) 82 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); 83 84 if (NoAliasTag) 85 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); 86 87 return CI; 88 } 89 90 CallInst *IRBuilderBase:: 91 CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align, 92 bool isVolatile, MDNode *TBAATag, MDNode *TBAAStructTag, 93 MDNode *ScopeTag, MDNode *NoAliasTag) { 94 Dst = getCastedInt8PtrValue(Dst); 95 Src = getCastedInt8PtrValue(Src); 96 97 Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) }; 98 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; 99 Module *M = BB->getParent()->getParent(); 100 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys); 101 102 CallInst *CI = createCallHelper(TheFn, Ops, this); 103 104 // Set the TBAA info if present. 105 if (TBAATag) 106 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); 107 108 // Set the TBAA Struct info if present. 109 if (TBAAStructTag) 110 CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag); 111 112 if (ScopeTag) 113 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); 114 115 if (NoAliasTag) 116 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); 117 118 return CI; 119 } 120 121 CallInst *IRBuilderBase:: 122 CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align, 123 bool isVolatile, MDNode *TBAATag, MDNode *ScopeTag, 124 MDNode *NoAliasTag) { 125 Dst = getCastedInt8PtrValue(Dst); 126 Src = getCastedInt8PtrValue(Src); 127 128 Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) }; 129 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; 130 Module *M = BB->getParent()->getParent(); 131 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys); 132 133 CallInst *CI = createCallHelper(TheFn, Ops, this); 134 135 // Set the TBAA info if present. 136 if (TBAATag) 137 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); 138 139 if (ScopeTag) 140 CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); 141 142 if (NoAliasTag) 143 CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); 144 145 return CI; 146 } 147 148 CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) { 149 assert(isa<PointerType>(Ptr->getType()) && 150 "lifetime.start only applies to pointers."); 151 Ptr = getCastedInt8PtrValue(Ptr); 152 if (!Size) 153 Size = getInt64(-1); 154 else 155 assert(Size->getType() == getInt64Ty() && 156 "lifetime.start requires the size to be an i64"); 157 Value *Ops[] = { Size, Ptr }; 158 Module *M = BB->getParent()->getParent(); 159 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start); 160 return createCallHelper(TheFn, Ops, this); 161 } 162 163 CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) { 164 assert(isa<PointerType>(Ptr->getType()) && 165 "lifetime.end only applies to pointers."); 166 Ptr = getCastedInt8PtrValue(Ptr); 167 if (!Size) 168 Size = getInt64(-1); 169 else 170 assert(Size->getType() == getInt64Ty() && 171 "lifetime.end requires the size to be an i64"); 172 Value *Ops[] = { Size, Ptr }; 173 Module *M = BB->getParent()->getParent(); 174 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end); 175 return createCallHelper(TheFn, Ops, this); 176 } 177 178 CallInst *IRBuilderBase::CreateAssumption(Value *Cond) { 179 assert(Cond->getType() == getInt1Ty() && 180 "an assumption condition must be of type i1"); 181 182 Value *Ops[] = { Cond }; 183 Module *M = BB->getParent()->getParent(); 184 Value *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume); 185 return createCallHelper(FnAssume, Ops, this); 186 } 187 188 /// Create a call to a Masked Load intrinsic. 189 /// Ptr - the base pointer for the load 190 /// Align - alignment of the source location 191 /// Mask - an vector of booleans which indicates what vector lanes should 192 /// be accessed in memory 193 /// PassThru - a pass-through value that is used to fill the masked-off lanes 194 /// of the result 195 /// Name - name of the result variable 196 CallInst *IRBuilderBase::CreateMaskedLoad(Value *Ptr, unsigned Align, 197 Value *Mask, Value *PassThru, 198 const Twine &Name) { 199 assert(Ptr->getType()->isPointerTy() && "Ptr must be of pointer type"); 200 // DataTy is the overloaded type 201 Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType(); 202 assert(DataTy->isVectorTy() && "Ptr should point to a vector"); 203 if (!PassThru) 204 PassThru = UndefValue::get(DataTy); 205 Value *Ops[] = { Ptr, getInt32(Align), Mask, PassThru}; 206 return CreateMaskedIntrinsic(Intrinsic::masked_load, Ops, DataTy, Name); 207 } 208 209 /// Create a call to a Masked Store intrinsic. 210 /// Val - the data to be stored, 211 /// Ptr - the base pointer for the store 212 /// Align - alignment of the destination location 213 /// Mask - an vector of booleans which indicates what vector lanes should 214 /// be accessed in memory 215 CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr, 216 unsigned Align, Value *Mask) { 217 Value *Ops[] = { Val, Ptr, getInt32(Align), Mask }; 218 // Type of the data to be stored - the only one overloaded type 219 return CreateMaskedIntrinsic(Intrinsic::masked_store, Ops, Val->getType()); 220 } 221 222 /// Create a call to a Masked intrinsic, with given intrinsic Id, 223 /// an array of operands - Ops, and one overloaded type - DataTy 224 CallInst *IRBuilderBase::CreateMaskedIntrinsic(unsigned Id, 225 ArrayRef<Value *> Ops, 226 Type *DataTy, 227 const Twine &Name) { 228 Module *M = BB->getParent()->getParent(); 229 Type *OverloadedTypes[] = { DataTy }; 230 Value *TheFn = Intrinsic::getDeclaration(M, (Intrinsic::ID)Id, OverloadedTypes); 231 return createCallHelper(TheFn, Ops, this, Name); 232 } 233 234 CallInst *IRBuilderBase::CreateGCStatepoint(Value *ActualCallee, 235 ArrayRef<Value *> CallArgs, 236 ArrayRef<Value *> DeoptArgs, 237 ArrayRef<Value *> GCArgs, 238 const Twine &Name) { 239 // Extract out the type of the callee. 240 PointerType *FuncPtrType = cast<PointerType>(ActualCallee->getType()); 241 assert(isa<FunctionType>(FuncPtrType->getElementType()) && 242 "actual callee must be a callable value"); 243 244 245 Module *M = BB->getParent()->getParent(); 246 // Fill in the one generic type'd argument (the function is also vararg) 247 Type *ArgTypes[] = { FuncPtrType }; 248 Function *FnStatepoint = 249 Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_statepoint, 250 ArgTypes); 251 252 std::vector<llvm::Value *> args; 253 args.push_back(ActualCallee); 254 args.push_back(getInt32(CallArgs.size())); 255 args.push_back(getInt32(0 /*unused*/)); 256 args.insert(args.end(), CallArgs.begin(), CallArgs.end()); 257 args.push_back(getInt32(DeoptArgs.size())); 258 args.insert(args.end(), DeoptArgs.begin(), DeoptArgs.end()); 259 args.insert(args.end(), GCArgs.begin(), GCArgs.end()); 260 261 return createCallHelper(FnStatepoint, args, this, Name); 262 } 263 264 CallInst *IRBuilderBase::CreateGCStatepoint(Value *ActualCallee, 265 ArrayRef<Use> CallArgs, 266 ArrayRef<Value *> DeoptArgs, 267 ArrayRef<Value *> GCArgs, 268 const Twine &Name) { 269 std::vector<Value *> VCallArgs; 270 for (auto &U : CallArgs) 271 VCallArgs.push_back(U.get()); 272 return CreateGCStatepoint(ActualCallee, VCallArgs, DeoptArgs, GCArgs, Name); 273 } 274 275 CallInst *IRBuilderBase::CreateGCResult(Instruction *Statepoint, 276 Type *ResultType, 277 const Twine &Name) { 278 Intrinsic::ID ID = Intrinsic::experimental_gc_result; 279 Module *M = BB->getParent()->getParent(); 280 Type *Types[] = {ResultType}; 281 Value *FnGCResult = Intrinsic::getDeclaration(M, ID, Types); 282 283 Value *Args[] = {Statepoint}; 284 return createCallHelper(FnGCResult, Args, this, Name); 285 } 286 287 CallInst *IRBuilderBase::CreateGCRelocate(Instruction *Statepoint, 288 int BaseOffset, 289 int DerivedOffset, 290 Type *ResultType, 291 const Twine &Name) { 292 Module *M = BB->getParent()->getParent(); 293 Type *Types[] = {ResultType}; 294 Value *FnGCRelocate = 295 Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_relocate, Types); 296 297 Value *Args[] = {Statepoint, 298 getInt32(BaseOffset), 299 getInt32(DerivedOffset)}; 300 return createCallHelper(FnGCRelocate, Args, this, Name); 301 } 302
