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 Value *IRBuilderBase::CreateGlobalString(StringRef Str, const Twine &Name) { 27 Constant *StrConstant = ConstantDataArray::getString(Context, Str); 28 Module &M = *BB->getParent()->getParent(); 29 GlobalVariable *GV = new GlobalVariable(M, StrConstant->getType(), 30 true, GlobalValue::PrivateLinkage, 31 StrConstant); 32 GV->setName(Name); 33 GV->setUnnamedAddr(true); 34 return GV; 35 } 36 37 Type *IRBuilderBase::getCurrentFunctionReturnType() const { 38 assert(BB && BB->getParent() && "No current function!"); 39 return BB->getParent()->getReturnType(); 40 } 41 42 Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) { 43 PointerType *PT = cast<PointerType>(Ptr->getType()); 44 if (PT->getElementType()->isIntegerTy(8)) 45 return Ptr; 46 47 // Otherwise, we need to insert a bitcast. 48 PT = getInt8PtrTy(PT->getAddressSpace()); 49 BitCastInst *BCI = new BitCastInst(Ptr, PT, ""); 50 BB->getInstList().insert(InsertPt, BCI); 51 SetInstDebugLocation(BCI); 52 return BCI; 53 } 54 55 static CallInst *createCallHelper(Value *Callee, ArrayRef<Value *> Ops, 56 IRBuilderBase *Builder) { 57 CallInst *CI = CallInst::Create(Callee, Ops, ""); 58 Builder->GetInsertBlock()->getInstList().insert(Builder->GetInsertPoint(),CI); 59 Builder->SetInstDebugLocation(CI); 60 return CI; 61 } 62 63 CallInst *IRBuilderBase:: 64 CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align, 65 bool isVolatile, MDNode *TBAATag) { 66 Ptr = getCastedInt8PtrValue(Ptr); 67 Value *Ops[] = { Ptr, Val, Size, getInt32(Align), getInt1(isVolatile) }; 68 Type *Tys[] = { Ptr->getType(), Size->getType() }; 69 Module *M = BB->getParent()->getParent(); 70 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys); 71 72 CallInst *CI = createCallHelper(TheFn, Ops, this); 73 74 // Set the TBAA info if present. 75 if (TBAATag) 76 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); 77 78 return CI; 79 } 80 81 CallInst *IRBuilderBase:: 82 CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align, 83 bool isVolatile, MDNode *TBAATag, MDNode *TBAAStructTag) { 84 Dst = getCastedInt8PtrValue(Dst); 85 Src = getCastedInt8PtrValue(Src); 86 87 Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) }; 88 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; 89 Module *M = BB->getParent()->getParent(); 90 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys); 91 92 CallInst *CI = createCallHelper(TheFn, Ops, this); 93 94 // Set the TBAA info if present. 95 if (TBAATag) 96 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); 97 98 // Set the TBAA Struct info if present. 99 if (TBAAStructTag) 100 CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag); 101 102 return CI; 103 } 104 105 CallInst *IRBuilderBase:: 106 CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align, 107 bool isVolatile, MDNode *TBAATag) { 108 Dst = getCastedInt8PtrValue(Dst); 109 Src = getCastedInt8PtrValue(Src); 110 111 Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) }; 112 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; 113 Module *M = BB->getParent()->getParent(); 114 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys); 115 116 CallInst *CI = createCallHelper(TheFn, Ops, this); 117 118 // Set the TBAA info if present. 119 if (TBAATag) 120 CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); 121 122 return CI; 123 } 124 125 CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) { 126 assert(isa<PointerType>(Ptr->getType()) && 127 "lifetime.start only applies to pointers."); 128 Ptr = getCastedInt8PtrValue(Ptr); 129 if (!Size) 130 Size = getInt64(-1); 131 else 132 assert(Size->getType() == getInt64Ty() && 133 "lifetime.start requires the size to be an i64"); 134 Value *Ops[] = { Size, Ptr }; 135 Module *M = BB->getParent()->getParent(); 136 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_start); 137 return createCallHelper(TheFn, Ops, this); 138 } 139 140 CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) { 141 assert(isa<PointerType>(Ptr->getType()) && 142 "lifetime.end only applies to pointers."); 143 Ptr = getCastedInt8PtrValue(Ptr); 144 if (!Size) 145 Size = getInt64(-1); 146 else 147 assert(Size->getType() == getInt64Ty() && 148 "lifetime.end requires the size to be an i64"); 149 Value *Ops[] = { Size, Ptr }; 150 Module *M = BB->getParent()->getParent(); 151 Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::lifetime_end); 152 return createCallHelper(TheFn, Ops, this); 153 } 154
