IRBuilder.h revision 046e78ce55a7c3d82b7b6758d2d77f2d99f970bf
1//===---- llvm/Support/IRBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===// 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 defines 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#ifndef LLVM_SUPPORT_IRBUILDER_H 16#define LLVM_SUPPORT_IRBUILDER_H 17 18#include "llvm/Constants.h" 19#include "llvm/Instructions.h" 20#include "llvm/GlobalAlias.h" 21#include "llvm/GlobalVariable.h" 22#include "llvm/Function.h" 23#include "llvm/Metadata.h" 24#include "llvm/LLVMContext.h" 25#include "llvm/ADT/Twine.h" 26#include "llvm/Support/ConstantFolder.h" 27 28namespace llvm { 29 30/// IRBuilderDefaultInserter - This provides the default implementation of the 31/// IRBuilder 'InsertHelper' method that is called whenever an instruction is 32/// created by IRBuilder and needs to be inserted. By default, this inserts the 33/// instruction at the insertion point. 34template <bool preserveNames = true> 35class IRBuilderDefaultInserter { 36protected: 37 void InsertHelper(Instruction *I, const Twine &Name, 38 BasicBlock *BB, BasicBlock::iterator InsertPt) const { 39 if (BB) BB->getInstList().insert(InsertPt, I); 40 if (preserveNames) 41 I->setName(Name); 42 } 43}; 44 45 46/// IRBuilder - This provides a uniform API for creating instructions and 47/// inserting them into a basic block: either at the end of a BasicBlock, or 48/// at a specific iterator location in a block. 49/// 50/// Note that the builder does not expose the full generality of LLVM 51/// instructions. For access to extra instruction properties, use the mutators 52/// (e.g. setVolatile) on the instructions after they have been created. 53/// The first template argument handles whether or not to preserve names in the 54/// final instruction output. This defaults to on. The second template argument 55/// specifies a class to use for creating constants. This defaults to creating 56/// minimally folded constants. The fourth template argument allows clients to 57/// specify custom insertion hooks that are called on every newly created 58/// insertion. 59template<bool preserveNames = true, typename T = ConstantFolder, 60 typename Inserter = IRBuilderDefaultInserter<preserveNames> > 61class IRBuilder : public Inserter { 62 BasicBlock *BB; 63 BasicBlock::iterator InsertPt; 64 unsigned MDKind; 65 MDNode *CurDbgLocation; 66 LLVMContext &Context; 67 T Folder; 68public: 69 IRBuilder(LLVMContext &C, const T &F, const Inserter &I = Inserter()) 70 : Inserter(I), MDKind(0), CurDbgLocation(0), Context(C), Folder(F) { 71 ClearInsertionPoint(); 72 } 73 74 explicit IRBuilder(LLVMContext &C) 75 : MDKind(0), CurDbgLocation(0), Context(C), Folder(C) { 76 ClearInsertionPoint(); 77 } 78 79 explicit IRBuilder(BasicBlock *TheBB, const T &F) 80 : MDKind(0), CurDbgLocation(0), Context(TheBB->getContext()), Folder(F) { 81 SetInsertPoint(TheBB); 82 } 83 84 explicit IRBuilder(BasicBlock *TheBB) 85 : MDKind(0), CurDbgLocation(0), Context(TheBB->getContext()), 86 Folder(Context) { 87 SetInsertPoint(TheBB); 88 } 89 90 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T& F) 91 : MDKind(0), CurDbgLocation(0), Context(TheBB->getContext()), Folder(F) { 92 SetInsertPoint(TheBB, IP); 93 } 94 95 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) 96 : MDKind(0), CurDbgLocation(0), Context(TheBB->getContext()), 97 Folder(Context) { 98 SetInsertPoint(TheBB, IP); 99 } 100 101 /// getFolder - Get the constant folder being used. 102 const T &getFolder() { return Folder; } 103 104 /// isNamePreserving - Return true if this builder is configured to actually 105 /// add the requested names to IR created through it. 106 bool isNamePreserving() const { return preserveNames; } 107 108 //===--------------------------------------------------------------------===// 109 // Builder configuration methods 110 //===--------------------------------------------------------------------===// 111 112 /// ClearInsertionPoint - Clear the insertion point: created instructions will 113 /// not be inserted into a block. 114 void ClearInsertionPoint() { 115 BB = 0; 116 } 117 118 BasicBlock *GetInsertBlock() const { return BB; } 119 120 BasicBlock::iterator GetInsertPoint() const { return InsertPt; } 121 122 /// SetInsertPoint - This specifies that created instructions should be 123 /// appended to the end of the specified block. 124 void SetInsertPoint(BasicBlock *TheBB) { 125 BB = TheBB; 126 InsertPt = BB->end(); 127 } 128 129 /// SetInsertPoint - This specifies that created instructions should be 130 /// inserted at the specified point. 131 void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) { 132 BB = TheBB; 133 InsertPt = IP; 134 } 135 136 /// SetCurrentDebugLocation - Set location information used by debugging 137 /// information. 138 void SetCurrentDebugLocation(MDNode *L) { 139 if (MDKind == 0) 140 MDKind = Context.getMetadata().getMDKind("dbg"); 141 if (MDKind == 0) 142 MDKind = Context.getMetadata().registerMDKind("dbg"); 143 CurDbgLocation = L; 144 } 145 146 MDNode *getCurrentDebugLocation() const { return CurDbgLocation; } 147 148 /// SetDebugLocation - Set location information for the given instruction. 149 void SetDebugLocation(Instruction *I) { 150 if (CurDbgLocation) 151 Context.getMetadata().addMD(MDKind, CurDbgLocation, I); 152 } 153 154 /// Insert - Insert and return the specified instruction. 155 template<typename InstTy> 156 InstTy *Insert(InstTy *I, const Twine &Name = "") const { 157 this->InsertHelper(I, Name, BB, InsertPt); 158 if (CurDbgLocation) 159 Context.getMetadata().addMD(MDKind, CurDbgLocation, I); 160 return I; 161 } 162 163 //===--------------------------------------------------------------------===// 164 // Type creation methods 165 //===--------------------------------------------------------------------===// 166 167 /// getInt1Ty - Fetch the type representing a single bit 168 const Type *getInt1Ty() { 169 return Type::getInt1Ty(Context); 170 } 171 172 /// getInt8Ty - Fetch the type representing an 8-bit integer. 173 const Type *getInt8Ty() { 174 return Type::getInt8Ty(Context); 175 } 176 177 /// getInt16Ty - Fetch the type representing a 16-bit integer. 178 const Type *getInt16Ty() { 179 return Type::getInt16Ty(Context); 180 } 181 182 /// getInt32Ty - Fetch the type resepresenting a 32-bit integer. 183 const Type *getInt32Ty() { 184 return Type::getInt32Ty(Context); 185 } 186 187 /// getInt64Ty - Fetch the type representing a 64-bit integer. 188 const Type *getInt64Ty() { 189 return Type::getInt64Ty(Context); 190 } 191 192 /// getFloatTy - Fetch the type representing a 32-bit floating point value. 193 const Type *getFloatTy() { 194 return Type::getFloatTy(Context); 195 } 196 197 /// getDoubleTy - Fetch the type representing a 64-bit floating point value. 198 const Type *getDoubleTy() { 199 return Type::getDoubleTy(Context); 200 } 201 202 /// getVoidTy - Fetch the type representing void. 203 const Type *getVoidTy() { 204 return Type::getVoidTy(Context); 205 } 206 207 //===--------------------------------------------------------------------===// 208 // Instruction creation methods: Terminators 209 //===--------------------------------------------------------------------===// 210 211 /// CreateRetVoid - Create a 'ret void' instruction. 212 ReturnInst *CreateRetVoid() { 213 return Insert(ReturnInst::Create(Context)); 214 } 215 216 /// @verbatim 217 /// CreateRet - Create a 'ret <val>' instruction. 218 /// @endverbatim 219 ReturnInst *CreateRet(Value *V) { 220 return Insert(ReturnInst::Create(Context, V)); 221 } 222 223 /// CreateAggregateRet - Create a sequence of N insertvalue instructions, 224 /// with one Value from the retVals array each, that build a aggregate 225 /// return value one value at a time, and a ret instruction to return 226 /// the resulting aggregate value. This is a convenience function for 227 /// code that uses aggregate return values as a vehicle for having 228 /// multiple return values. 229 /// 230 ReturnInst *CreateAggregateRet(Value * const* retVals, unsigned N) { 231 const Type *RetType = BB->getParent()->getReturnType(); 232 Value *V = UndefValue::get(RetType); 233 for (unsigned i = 0; i != N; ++i) 234 V = CreateInsertValue(V, retVals[i], i, "mrv"); 235 return Insert(ReturnInst::Create(Context, V)); 236 } 237 238 /// CreateBr - Create an unconditional 'br label X' instruction. 239 BranchInst *CreateBr(BasicBlock *Dest) { 240 return Insert(BranchInst::Create(Dest)); 241 } 242 243 /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest' 244 /// instruction. 245 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) { 246 return Insert(BranchInst::Create(True, False, Cond)); 247 } 248 249 /// CreateSwitch - Create a switch instruction with the specified value, 250 /// default dest, and with a hint for the number of cases that will be added 251 /// (for efficient allocation). 252 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) { 253 return Insert(SwitchInst::Create(V, Dest, NumCases)); 254 } 255 256 /// CreateInvoke - Create an invoke instruction. 257 template<typename InputIterator> 258 InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, 259 BasicBlock *UnwindDest, InputIterator ArgBegin, 260 InputIterator ArgEnd, const Twine &Name = "") { 261 return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, 262 ArgBegin, ArgEnd), Name); 263 } 264 265 UnwindInst *CreateUnwind() { 266 return Insert(new UnwindInst(Context)); 267 } 268 269 UnreachableInst *CreateUnreachable() { 270 return Insert(new UnreachableInst(Context)); 271 } 272 273 //===--------------------------------------------------------------------===// 274 // Instruction creation methods: Binary Operators 275 //===--------------------------------------------------------------------===// 276 277 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 278 if (Constant *LC = dyn_cast<Constant>(LHS)) 279 if (Constant *RC = dyn_cast<Constant>(RHS)) 280 return Folder.CreateAdd(LC, RC); 281 return Insert(BinaryOperator::CreateAdd(LHS, RHS), Name); 282 } 283 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 284 if (Constant *LC = dyn_cast<Constant>(LHS)) 285 if (Constant *RC = dyn_cast<Constant>(RHS)) 286 return Folder.CreateNSWAdd(LC, RC); 287 return Insert(BinaryOperator::CreateNSWAdd(LHS, RHS), Name); 288 } 289 Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 290 if (Constant *LC = dyn_cast<Constant>(LHS)) 291 if (Constant *RC = dyn_cast<Constant>(RHS)) 292 return Folder.CreateFAdd(LC, RC); 293 return Insert(BinaryOperator::CreateFAdd(LHS, RHS), Name); 294 } 295 Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "") { 296 if (Constant *LC = dyn_cast<Constant>(LHS)) 297 if (Constant *RC = dyn_cast<Constant>(RHS)) 298 return Folder.CreateSub(LC, RC); 299 return Insert(BinaryOperator::CreateSub(LHS, RHS), Name); 300 } 301 Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") { 302 if (Constant *LC = dyn_cast<Constant>(LHS)) 303 if (Constant *RC = dyn_cast<Constant>(RHS)) 304 return Folder.CreateNSWSub(LC, RC); 305 return Insert(BinaryOperator::CreateNSWSub(LHS, RHS), Name); 306 } 307 Value *CreateFSub(Value *LHS, Value *RHS, const Twine &Name = "") { 308 if (Constant *LC = dyn_cast<Constant>(LHS)) 309 if (Constant *RC = dyn_cast<Constant>(RHS)) 310 return Folder.CreateFSub(LC, RC); 311 return Insert(BinaryOperator::CreateFSub(LHS, RHS), Name); 312 } 313 Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "") { 314 if (Constant *LC = dyn_cast<Constant>(LHS)) 315 if (Constant *RC = dyn_cast<Constant>(RHS)) 316 return Folder.CreateMul(LC, RC); 317 return Insert(BinaryOperator::CreateMul(LHS, RHS), Name); 318 } 319 Value *CreateFMul(Value *LHS, Value *RHS, const Twine &Name = "") { 320 if (Constant *LC = dyn_cast<Constant>(LHS)) 321 if (Constant *RC = dyn_cast<Constant>(RHS)) 322 return Folder.CreateFMul(LC, RC); 323 return Insert(BinaryOperator::CreateFMul(LHS, RHS), Name); 324 } 325 Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 326 if (Constant *LC = dyn_cast<Constant>(LHS)) 327 if (Constant *RC = dyn_cast<Constant>(RHS)) 328 return Folder.CreateUDiv(LC, RC); 329 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name); 330 } 331 Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 332 if (Constant *LC = dyn_cast<Constant>(LHS)) 333 if (Constant *RC = dyn_cast<Constant>(RHS)) 334 return Folder.CreateSDiv(LC, RC); 335 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name); 336 } 337 Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 338 if (Constant *LC = dyn_cast<Constant>(LHS)) 339 if (Constant *RC = dyn_cast<Constant>(RHS)) 340 return Folder.CreateExactSDiv(LC, RC); 341 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name); 342 } 343 Value *CreateFDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 344 if (Constant *LC = dyn_cast<Constant>(LHS)) 345 if (Constant *RC = dyn_cast<Constant>(RHS)) 346 return Folder.CreateFDiv(LC, RC); 347 return Insert(BinaryOperator::CreateFDiv(LHS, RHS), Name); 348 } 349 Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") { 350 if (Constant *LC = dyn_cast<Constant>(LHS)) 351 if (Constant *RC = dyn_cast<Constant>(RHS)) 352 return Folder.CreateURem(LC, RC); 353 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name); 354 } 355 Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") { 356 if (Constant *LC = dyn_cast<Constant>(LHS)) 357 if (Constant *RC = dyn_cast<Constant>(RHS)) 358 return Folder.CreateSRem(LC, RC); 359 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name); 360 } 361 Value *CreateFRem(Value *LHS, Value *RHS, const Twine &Name = "") { 362 if (Constant *LC = dyn_cast<Constant>(LHS)) 363 if (Constant *RC = dyn_cast<Constant>(RHS)) 364 return Folder.CreateFRem(LC, RC); 365 return Insert(BinaryOperator::CreateFRem(LHS, RHS), Name); 366 } 367 Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "") { 368 if (Constant *LC = dyn_cast<Constant>(LHS)) 369 if (Constant *RC = dyn_cast<Constant>(RHS)) 370 return Folder.CreateShl(LC, RC); 371 return Insert(BinaryOperator::CreateShl(LHS, RHS), Name); 372 } 373 Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "") { 374 if (Constant *LC = dyn_cast<Constant>(LHS)) 375 if (Constant *RC = dyn_cast<Constant>(RHS)) 376 return Folder.CreateLShr(LC, RC); 377 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name); 378 } 379 Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "") { 380 if (Constant *LC = dyn_cast<Constant>(LHS)) 381 if (Constant *RC = dyn_cast<Constant>(RHS)) 382 return Folder.CreateAShr(LC, RC); 383 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name); 384 } 385 Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") { 386 if (Constant *LC = dyn_cast<Constant>(LHS)) 387 if (Constant *RC = dyn_cast<Constant>(RHS)) 388 return Folder.CreateAnd(LC, RC); 389 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name); 390 } 391 Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") { 392 if (Constant *LC = dyn_cast<Constant>(LHS)) 393 if (Constant *RC = dyn_cast<Constant>(RHS)) 394 return Folder.CreateOr(LC, RC); 395 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name); 396 } 397 Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") { 398 if (Constant *LC = dyn_cast<Constant>(LHS)) 399 if (Constant *RC = dyn_cast<Constant>(RHS)) 400 return Folder.CreateXor(LC, RC); 401 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name); 402 } 403 404 Value *CreateBinOp(Instruction::BinaryOps Opc, 405 Value *LHS, Value *RHS, const Twine &Name = "") { 406 if (Constant *LC = dyn_cast<Constant>(LHS)) 407 if (Constant *RC = dyn_cast<Constant>(RHS)) 408 return Folder.CreateBinOp(Opc, LC, RC); 409 return Insert(BinaryOperator::Create(Opc, LHS, RHS), Name); 410 } 411 412 Value *CreateNeg(Value *V, const Twine &Name = "") { 413 if (Constant *VC = dyn_cast<Constant>(V)) 414 return Folder.CreateNeg(VC); 415 return Insert(BinaryOperator::CreateNeg(V), Name); 416 } 417 Value *CreateFNeg(Value *V, const Twine &Name = "") { 418 if (Constant *VC = dyn_cast<Constant>(V)) 419 return Folder.CreateFNeg(VC); 420 return Insert(BinaryOperator::CreateFNeg(V), Name); 421 } 422 Value *CreateNot(Value *V, const Twine &Name = "") { 423 if (Constant *VC = dyn_cast<Constant>(V)) 424 return Folder.CreateNot(VC); 425 return Insert(BinaryOperator::CreateNot(V), Name); 426 } 427 428 //===--------------------------------------------------------------------===// 429 // Instruction creation methods: Memory Instructions 430 //===--------------------------------------------------------------------===// 431 432 AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0, 433 const Twine &Name = "") { 434 return Insert(new AllocaInst(Ty, ArraySize), Name); 435 } 436 // Provided to resolve 'CreateLoad(Ptr, "...")' correctly, instead of 437 // converting the string to 'bool' for the isVolatile parameter. 438 LoadInst *CreateLoad(Value *Ptr, const char *Name) { 439 return Insert(new LoadInst(Ptr), Name); 440 } 441 LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") { 442 return Insert(new LoadInst(Ptr), Name); 443 } 444 LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") { 445 return Insert(new LoadInst(Ptr, 0, isVolatile), Name); 446 } 447 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) { 448 return Insert(new StoreInst(Val, Ptr, isVolatile)); 449 } 450 template<typename InputIterator> 451 Value *CreateGEP(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd, 452 const Twine &Name = "") { 453 if (Constant *PC = dyn_cast<Constant>(Ptr)) { 454 // Every index must be constant. 455 InputIterator i; 456 for (i = IdxBegin; i < IdxEnd; ++i) 457 if (!isa<Constant>(*i)) 458 break; 459 if (i == IdxEnd) 460 return Folder.CreateGetElementPtr(PC, &IdxBegin[0], IdxEnd - IdxBegin); 461 } 462 return Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd), Name); 463 } 464 template<typename InputIterator> 465 Value *CreateInBoundsGEP(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd, 466 const Twine &Name = "") { 467 if (Constant *PC = dyn_cast<Constant>(Ptr)) { 468 // Every index must be constant. 469 InputIterator i; 470 for (i = IdxBegin; i < IdxEnd; ++i) 471 if (!isa<Constant>(*i)) 472 break; 473 if (i == IdxEnd) 474 return Folder.CreateInBoundsGetElementPtr(PC, 475 &IdxBegin[0], 476 IdxEnd - IdxBegin); 477 } 478 return Insert(GetElementPtrInst::CreateInBounds(Ptr, IdxBegin, IdxEnd), 479 Name); 480 } 481 Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") { 482 if (Constant *PC = dyn_cast<Constant>(Ptr)) 483 if (Constant *IC = dyn_cast<Constant>(Idx)) 484 return Folder.CreateGetElementPtr(PC, &IC, 1); 485 return Insert(GetElementPtrInst::Create(Ptr, Idx), Name); 486 } 487 Value *CreateInBoundsGEP(Value *Ptr, Value *Idx, const Twine &Name = "") { 488 if (Constant *PC = dyn_cast<Constant>(Ptr)) 489 if (Constant *IC = dyn_cast<Constant>(Idx)) 490 return Folder.CreateInBoundsGetElementPtr(PC, &IC, 1); 491 return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idx), Name); 492 } 493 Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") { 494 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0); 495 496 if (Constant *PC = dyn_cast<Constant>(Ptr)) 497 return Folder.CreateGetElementPtr(PC, &Idx, 1); 498 499 return Insert(GetElementPtrInst::Create(Ptr, &Idx, &Idx+1), Name); 500 } 501 Value *CreateConstInBoundsGEP1_32(Value *Ptr, unsigned Idx0, 502 const Twine &Name = "") { 503 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0); 504 505 if (Constant *PC = dyn_cast<Constant>(Ptr)) 506 return Folder.CreateInBoundsGetElementPtr(PC, &Idx, 1); 507 508 return Insert(GetElementPtrInst::CreateInBounds(Ptr, &Idx, &Idx+1), Name); 509 } 510 Value *CreateConstGEP2_32(Value *Ptr, unsigned Idx0, unsigned Idx1, 511 const Twine &Name = "") { 512 Value *Idxs[] = { 513 ConstantInt::get(Type::getInt32Ty(Context), Idx0), 514 ConstantInt::get(Type::getInt32Ty(Context), Idx1) 515 }; 516 517 if (Constant *PC = dyn_cast<Constant>(Ptr)) 518 return Folder.CreateGetElementPtr(PC, Idxs, 2); 519 520 return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2), Name); 521 } 522 Value *CreateConstInBoundsGEP2_32(Value *Ptr, unsigned Idx0, unsigned Idx1, 523 const Twine &Name = "") { 524 Value *Idxs[] = { 525 ConstantInt::get(Type::getInt32Ty(Context), Idx0), 526 ConstantInt::get(Type::getInt32Ty(Context), Idx1) 527 }; 528 529 if (Constant *PC = dyn_cast<Constant>(Ptr)) 530 return Folder.CreateInBoundsGetElementPtr(PC, Idxs, 2); 531 532 return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idxs, Idxs+2), Name); 533 } 534 Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") { 535 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0); 536 537 if (Constant *PC = dyn_cast<Constant>(Ptr)) 538 return Folder.CreateGetElementPtr(PC, &Idx, 1); 539 540 return Insert(GetElementPtrInst::Create(Ptr, &Idx, &Idx+1), Name); 541 } 542 Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0, 543 const Twine &Name = "") { 544 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0); 545 546 if (Constant *PC = dyn_cast<Constant>(Ptr)) 547 return Folder.CreateInBoundsGetElementPtr(PC, &Idx, 1); 548 549 return Insert(GetElementPtrInst::CreateInBounds(Ptr, &Idx, &Idx+1), Name); 550 } 551 Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, 552 const Twine &Name = "") { 553 Value *Idxs[] = { 554 ConstantInt::get(Type::getInt64Ty(Context), Idx0), 555 ConstantInt::get(Type::getInt64Ty(Context), Idx1) 556 }; 557 558 if (Constant *PC = dyn_cast<Constant>(Ptr)) 559 return Folder.CreateGetElementPtr(PC, Idxs, 2); 560 561 return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2), Name); 562 } 563 Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, 564 const Twine &Name = "") { 565 Value *Idxs[] = { 566 ConstantInt::get(Type::getInt64Ty(Context), Idx0), 567 ConstantInt::get(Type::getInt64Ty(Context), Idx1) 568 }; 569 570 if (Constant *PC = dyn_cast<Constant>(Ptr)) 571 return Folder.CreateInBoundsGetElementPtr(PC, Idxs, 2); 572 573 return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idxs, Idxs+2), Name); 574 } 575 Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") { 576 return CreateConstInBoundsGEP2_32(Ptr, 0, Idx, Name); 577 } 578 Value *CreateGlobalString(const char *Str = "", const Twine &Name = "") { 579 Constant *StrConstant = ConstantArray::get(Context, Str, true); 580 Module &M = *BB->getParent()->getParent(); 581 GlobalVariable *gv = new GlobalVariable(M, 582 StrConstant->getType(), 583 true, 584 GlobalValue::InternalLinkage, 585 StrConstant, 586 "", 587 0, 588 false); 589 gv->setName(Name); 590 return gv; 591 } 592 Value *CreateGlobalStringPtr(const char *Str = "", const Twine &Name = "") { 593 Value *gv = CreateGlobalString(Str, Name); 594 Value *zero = ConstantInt::get(Type::getInt32Ty(Context), 0); 595 Value *Args[] = { zero, zero }; 596 return CreateInBoundsGEP(gv, Args, Args+2, Name); 597 } 598 //===--------------------------------------------------------------------===// 599 // Instruction creation methods: Cast/Conversion Operators 600 //===--------------------------------------------------------------------===// 601 602 Value *CreateTrunc(Value *V, const Type *DestTy, const Twine &Name = "") { 603 return CreateCast(Instruction::Trunc, V, DestTy, Name); 604 } 605 Value *CreateZExt(Value *V, const Type *DestTy, const Twine &Name = "") { 606 return CreateCast(Instruction::ZExt, V, DestTy, Name); 607 } 608 Value *CreateSExt(Value *V, const Type *DestTy, const Twine &Name = "") { 609 return CreateCast(Instruction::SExt, V, DestTy, Name); 610 } 611 Value *CreateFPToUI(Value *V, const Type *DestTy, const Twine &Name = ""){ 612 return CreateCast(Instruction::FPToUI, V, DestTy, Name); 613 } 614 Value *CreateFPToSI(Value *V, const Type *DestTy, const Twine &Name = ""){ 615 return CreateCast(Instruction::FPToSI, V, DestTy, Name); 616 } 617 Value *CreateUIToFP(Value *V, const Type *DestTy, const Twine &Name = ""){ 618 return CreateCast(Instruction::UIToFP, V, DestTy, Name); 619 } 620 Value *CreateSIToFP(Value *V, const Type *DestTy, const Twine &Name = ""){ 621 return CreateCast(Instruction::SIToFP, V, DestTy, Name); 622 } 623 Value *CreateFPTrunc(Value *V, const Type *DestTy, 624 const Twine &Name = "") { 625 return CreateCast(Instruction::FPTrunc, V, DestTy, Name); 626 } 627 Value *CreateFPExt(Value *V, const Type *DestTy, const Twine &Name = "") { 628 return CreateCast(Instruction::FPExt, V, DestTy, Name); 629 } 630 Value *CreatePtrToInt(Value *V, const Type *DestTy, 631 const Twine &Name = "") { 632 return CreateCast(Instruction::PtrToInt, V, DestTy, Name); 633 } 634 Value *CreateIntToPtr(Value *V, const Type *DestTy, 635 const Twine &Name = "") { 636 return CreateCast(Instruction::IntToPtr, V, DestTy, Name); 637 } 638 Value *CreateBitCast(Value *V, const Type *DestTy, 639 const Twine &Name = "") { 640 return CreateCast(Instruction::BitCast, V, DestTy, Name); 641 } 642 Value *CreateZExtOrBitCast(Value *V, const Type *DestTy, 643 const Twine &Name = "") { 644 if (V->getType() == DestTy) 645 return V; 646 if (Constant *VC = dyn_cast<Constant>(V)) 647 return Folder.CreateZExtOrBitCast(VC, DestTy); 648 return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name); 649 } 650 Value *CreateSExtOrBitCast(Value *V, const Type *DestTy, 651 const Twine &Name = "") { 652 if (V->getType() == DestTy) 653 return V; 654 if (Constant *VC = dyn_cast<Constant>(V)) 655 return Folder.CreateSExtOrBitCast(VC, DestTy); 656 return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name); 657 } 658 Value *CreateTruncOrBitCast(Value *V, const Type *DestTy, 659 const Twine &Name = "") { 660 if (V->getType() == DestTy) 661 return V; 662 if (Constant *VC = dyn_cast<Constant>(V)) 663 return Folder.CreateTruncOrBitCast(VC, DestTy); 664 return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name); 665 } 666 Value *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy, 667 const Twine &Name = "") { 668 if (V->getType() == DestTy) 669 return V; 670 if (Constant *VC = dyn_cast<Constant>(V)) 671 return Folder.CreateCast(Op, VC, DestTy); 672 return Insert(CastInst::Create(Op, V, DestTy), Name); 673 } 674 Value *CreatePointerCast(Value *V, const Type *DestTy, 675 const Twine &Name = "") { 676 if (V->getType() == DestTy) 677 return V; 678 if (Constant *VC = dyn_cast<Constant>(V)) 679 return Folder.CreatePointerCast(VC, DestTy); 680 return Insert(CastInst::CreatePointerCast(V, DestTy), Name); 681 } 682 Value *CreateIntCast(Value *V, const Type *DestTy, bool isSigned, 683 const Twine &Name = "") { 684 if (V->getType() == DestTy) 685 return V; 686 if (Constant *VC = dyn_cast<Constant>(V)) 687 return Folder.CreateIntCast(VC, DestTy, isSigned); 688 return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name); 689 } 690 Value *CreateFPCast(Value *V, const Type *DestTy, const Twine &Name = "") { 691 if (V->getType() == DestTy) 692 return V; 693 if (Constant *VC = dyn_cast<Constant>(V)) 694 return Folder.CreateFPCast(VC, DestTy); 695 return Insert(CastInst::CreateFPCast(V, DestTy), Name); 696 } 697 698 //===--------------------------------------------------------------------===// 699 // Instruction creation methods: Compare Instructions 700 //===--------------------------------------------------------------------===// 701 702 Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 703 return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name); 704 } 705 Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") { 706 return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name); 707 } 708 Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") { 709 return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name); 710 } 711 Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") { 712 return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name); 713 } 714 Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") { 715 return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name); 716 } 717 Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") { 718 return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name); 719 } 720 Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") { 721 return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name); 722 } 723 Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") { 724 return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name); 725 } 726 Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") { 727 return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name); 728 } 729 Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") { 730 return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name); 731 } 732 733 Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 734 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name); 735 } 736 Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "") { 737 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name); 738 } 739 Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "") { 740 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name); 741 } 742 Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "") { 743 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name); 744 } 745 Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "") { 746 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name); 747 } 748 Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "") { 749 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name); 750 } 751 Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "") { 752 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name); 753 } 754 Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "") { 755 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name); 756 } 757 Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 758 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name); 759 } 760 Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") { 761 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name); 762 } 763 Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") { 764 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name); 765 } 766 Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "") { 767 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name); 768 } 769 Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "") { 770 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name); 771 } 772 Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "") { 773 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name); 774 } 775 776 Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, 777 const Twine &Name = "") { 778 if (Constant *LC = dyn_cast<Constant>(LHS)) 779 if (Constant *RC = dyn_cast<Constant>(RHS)) 780 return Folder.CreateICmp(P, LC, RC); 781 return Insert(new ICmpInst(P, LHS, RHS), Name); 782 } 783 Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, 784 const Twine &Name = "") { 785 if (Constant *LC = dyn_cast<Constant>(LHS)) 786 if (Constant *RC = dyn_cast<Constant>(RHS)) 787 return Folder.CreateFCmp(P, LC, RC); 788 return Insert(new FCmpInst(P, LHS, RHS), Name); 789 } 790 791 //===--------------------------------------------------------------------===// 792 // Instruction creation methods: Other Instructions 793 //===--------------------------------------------------------------------===// 794 795 PHINode *CreatePHI(const Type *Ty, const Twine &Name = "") { 796 return Insert(PHINode::Create(Ty), Name); 797 } 798 799 CallInst *CreateCall(Value *Callee, const Twine &Name = "") { 800 return Insert(CallInst::Create(Callee), Name); 801 } 802 CallInst *CreateCall(Value *Callee, Value *Arg, const Twine &Name = "") { 803 return Insert(CallInst::Create(Callee, Arg), Name); 804 } 805 CallInst *CreateCall2(Value *Callee, Value *Arg1, Value *Arg2, 806 const Twine &Name = "") { 807 Value *Args[] = { Arg1, Arg2 }; 808 return Insert(CallInst::Create(Callee, Args, Args+2), Name); 809 } 810 CallInst *CreateCall3(Value *Callee, Value *Arg1, Value *Arg2, Value *Arg3, 811 const Twine &Name = "") { 812 Value *Args[] = { Arg1, Arg2, Arg3 }; 813 return Insert(CallInst::Create(Callee, Args, Args+3), Name); 814 } 815 CallInst *CreateCall4(Value *Callee, Value *Arg1, Value *Arg2, Value *Arg3, 816 Value *Arg4, const Twine &Name = "") { 817 Value *Args[] = { Arg1, Arg2, Arg3, Arg4 }; 818 return Insert(CallInst::Create(Callee, Args, Args+4), Name); 819 } 820 821 template<typename InputIterator> 822 CallInst *CreateCall(Value *Callee, InputIterator ArgBegin, 823 InputIterator ArgEnd, const Twine &Name = "") { 824 return Insert(CallInst::Create(Callee, ArgBegin, ArgEnd), Name); 825 } 826 827 Value *CreateSelect(Value *C, Value *True, Value *False, 828 const Twine &Name = "") { 829 if (Constant *CC = dyn_cast<Constant>(C)) 830 if (Constant *TC = dyn_cast<Constant>(True)) 831 if (Constant *FC = dyn_cast<Constant>(False)) 832 return Folder.CreateSelect(CC, TC, FC); 833 return Insert(SelectInst::Create(C, True, False), Name); 834 } 835 836 VAArgInst *CreateVAArg(Value *List, const Type *Ty, const Twine &Name = "") { 837 return Insert(new VAArgInst(List, Ty), Name); 838 } 839 840 Value *CreateExtractElement(Value *Vec, Value *Idx, 841 const Twine &Name = "") { 842 if (Constant *VC = dyn_cast<Constant>(Vec)) 843 if (Constant *IC = dyn_cast<Constant>(Idx)) 844 return Folder.CreateExtractElement(VC, IC); 845 return Insert(ExtractElementInst::Create(Vec, Idx), Name); 846 } 847 848 Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, 849 const Twine &Name = "") { 850 if (Constant *VC = dyn_cast<Constant>(Vec)) 851 if (Constant *NC = dyn_cast<Constant>(NewElt)) 852 if (Constant *IC = dyn_cast<Constant>(Idx)) 853 return Folder.CreateInsertElement(VC, NC, IC); 854 return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name); 855 } 856 857 Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask, 858 const Twine &Name = "") { 859 if (Constant *V1C = dyn_cast<Constant>(V1)) 860 if (Constant *V2C = dyn_cast<Constant>(V2)) 861 if (Constant *MC = dyn_cast<Constant>(Mask)) 862 return Folder.CreateShuffleVector(V1C, V2C, MC); 863 return Insert(new ShuffleVectorInst(V1, V2, Mask), Name); 864 } 865 866 Value *CreateExtractValue(Value *Agg, unsigned Idx, 867 const Twine &Name = "") { 868 if (Constant *AggC = dyn_cast<Constant>(Agg)) 869 return Folder.CreateExtractValue(AggC, &Idx, 1); 870 return Insert(ExtractValueInst::Create(Agg, Idx), Name); 871 } 872 873 template<typename InputIterator> 874 Value *CreateExtractValue(Value *Agg, 875 InputIterator IdxBegin, 876 InputIterator IdxEnd, 877 const Twine &Name = "") { 878 if (Constant *AggC = dyn_cast<Constant>(Agg)) 879 return Folder.CreateExtractValue(AggC, IdxBegin, IdxEnd - IdxBegin); 880 return Insert(ExtractValueInst::Create(Agg, IdxBegin, IdxEnd), Name); 881 } 882 883 Value *CreateInsertValue(Value *Agg, Value *Val, unsigned Idx, 884 const Twine &Name = "") { 885 if (Constant *AggC = dyn_cast<Constant>(Agg)) 886 if (Constant *ValC = dyn_cast<Constant>(Val)) 887 return Folder.CreateInsertValue(AggC, ValC, &Idx, 1); 888 return Insert(InsertValueInst::Create(Agg, Val, Idx), Name); 889 } 890 891 template<typename InputIterator> 892 Value *CreateInsertValue(Value *Agg, Value *Val, 893 InputIterator IdxBegin, 894 InputIterator IdxEnd, 895 const Twine &Name = "") { 896 if (Constant *AggC = dyn_cast<Constant>(Agg)) 897 if (Constant *ValC = dyn_cast<Constant>(Val)) 898 return Folder.CreateInsertValue(AggC, ValC, IdxBegin, IdxEnd-IdxBegin); 899 return Insert(InsertValueInst::Create(Agg, Val, IdxBegin, IdxEnd), Name); 900 } 901 902 //===--------------------------------------------------------------------===// 903 // Utility creation methods 904 //===--------------------------------------------------------------------===// 905 906 /// CreateIsNull - Return an i1 value testing if \arg Arg is null. 907 Value *CreateIsNull(Value *Arg, const Twine &Name = "") { 908 return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()), 909 Name); 910 } 911 912 /// CreateIsNotNull - Return an i1 value testing if \arg Arg is not null. 913 Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") { 914 return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()), 915 Name); 916 } 917 918 /// CreatePtrDiff - Return the i64 difference between two pointer values, 919 /// dividing out the size of the pointed-to objects. This is intended to 920 /// implement C-style pointer subtraction. As such, the pointers must be 921 /// appropriately aligned for their element types and pointing into the 922 /// same object. 923 Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") { 924 assert(LHS->getType() == RHS->getType() && 925 "Pointer subtraction operand types must match!"); 926 const PointerType *ArgType = cast<PointerType>(LHS->getType()); 927 Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context)); 928 Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context)); 929 Value *Difference = CreateSub(LHS_int, RHS_int); 930 return CreateExactSDiv(Difference, 931 ConstantExpr::getSizeOf(ArgType->getElementType()), 932 Name); 933 } 934}; 935 936} 937 938#endif 939