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/Instructions.h" 19 #include "llvm/BasicBlock.h" 20 #include "llvm/ADT/ArrayRef.h" 21 #include "llvm/ADT/StringRef.h" 22 #include "llvm/ADT/Twine.h" 23 #include "llvm/Support/ConstantFolder.h" 24 25 namespace llvm { 26 class MDNode; 27 28 /// IRBuilderDefaultInserter - This provides the default implementation of the 29 /// IRBuilder 'InsertHelper' method that is called whenever an instruction is 30 /// created by IRBuilder and needs to be inserted. By default, this inserts the 31 /// instruction at the insertion point. 32 template <bool preserveNames = true> 33 class IRBuilderDefaultInserter { 34 protected: 35 void InsertHelper(Instruction *I, const Twine &Name, 36 BasicBlock *BB, BasicBlock::iterator InsertPt) const { 37 if (BB) BB->getInstList().insert(InsertPt, I); 38 if (preserveNames) 39 I->setName(Name); 40 } 41 }; 42 43 /// IRBuilderBase - Common base class shared among various IRBuilders. 44 class IRBuilderBase { 45 DebugLoc CurDbgLocation; 46 protected: 47 BasicBlock *BB; 48 BasicBlock::iterator InsertPt; 49 LLVMContext &Context; 50 public: 51 52 IRBuilderBase(LLVMContext &context) 53 : Context(context) { 54 ClearInsertionPoint(); 55 } 56 57 //===--------------------------------------------------------------------===// 58 // Builder configuration methods 59 //===--------------------------------------------------------------------===// 60 61 /// ClearInsertionPoint - Clear the insertion point: created instructions will 62 /// not be inserted into a block. 63 void ClearInsertionPoint() { 64 BB = 0; 65 } 66 67 BasicBlock *GetInsertBlock() const { return BB; } 68 BasicBlock::iterator GetInsertPoint() const { return InsertPt; } 69 LLVMContext &getContext() const { return Context; } 70 71 /// SetInsertPoint - This specifies that created instructions should be 72 /// appended to the end of the specified block. 73 void SetInsertPoint(BasicBlock *TheBB) { 74 BB = TheBB; 75 InsertPt = BB->end(); 76 } 77 78 /// SetInsertPoint - This specifies that created instructions should be 79 /// inserted before the specified instruction. 80 void SetInsertPoint(Instruction *I) { 81 BB = I->getParent(); 82 InsertPt = I; 83 SetCurrentDebugLocation(I->getDebugLoc()); 84 } 85 86 /// SetInsertPoint - This specifies that created instructions should be 87 /// inserted at the specified point. 88 void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) { 89 BB = TheBB; 90 InsertPt = IP; 91 } 92 93 /// SetInsertPoint(Use) - Find the nearest point that dominates this use, and 94 /// specify that created instructions should be inserted at this point. 95 void SetInsertPoint(Use &U) { 96 Instruction *UseInst = cast<Instruction>(U.getUser()); 97 if (PHINode *Phi = dyn_cast<PHINode>(UseInst)) { 98 BasicBlock *PredBB = Phi->getIncomingBlock(U); 99 assert(U != PredBB->getTerminator() && "critical edge not split"); 100 SetInsertPoint(PredBB, PredBB->getTerminator()); 101 return; 102 } 103 SetInsertPoint(UseInst); 104 } 105 106 /// SetCurrentDebugLocation - Set location information used by debugging 107 /// information. 108 void SetCurrentDebugLocation(const DebugLoc &L) { 109 CurDbgLocation = L; 110 } 111 112 /// getCurrentDebugLocation - Get location information used by debugging 113 /// information. 114 DebugLoc getCurrentDebugLocation() const { return CurDbgLocation; } 115 116 /// SetInstDebugLocation - If this builder has a current debug location, set 117 /// it on the specified instruction. 118 void SetInstDebugLocation(Instruction *I) const { 119 if (!CurDbgLocation.isUnknown()) 120 I->setDebugLoc(CurDbgLocation); 121 } 122 123 /// getCurrentFunctionReturnType - Get the return type of the current function 124 /// that we're emitting into. 125 Type *getCurrentFunctionReturnType() const; 126 127 /// InsertPoint - A saved insertion point. 128 class InsertPoint { 129 BasicBlock *Block; 130 BasicBlock::iterator Point; 131 132 public: 133 /// Creates a new insertion point which doesn't point to anything. 134 InsertPoint() : Block(0) {} 135 136 /// Creates a new insertion point at the given location. 137 InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint) 138 : Block(InsertBlock), Point(InsertPoint) {} 139 140 /// isSet - Returns true if this insert point is set. 141 bool isSet() const { return (Block != 0); } 142 143 llvm::BasicBlock *getBlock() const { return Block; } 144 llvm::BasicBlock::iterator getPoint() const { return Point; } 145 }; 146 147 /// saveIP - Returns the current insert point. 148 InsertPoint saveIP() const { 149 return InsertPoint(GetInsertBlock(), GetInsertPoint()); 150 } 151 152 /// saveAndClearIP - Returns the current insert point, clearing it 153 /// in the process. 154 InsertPoint saveAndClearIP() { 155 InsertPoint IP(GetInsertBlock(), GetInsertPoint()); 156 ClearInsertionPoint(); 157 return IP; 158 } 159 160 /// restoreIP - Sets the current insert point to a previously-saved 161 /// location. 162 void restoreIP(InsertPoint IP) { 163 if (IP.isSet()) 164 SetInsertPoint(IP.getBlock(), IP.getPoint()); 165 else 166 ClearInsertionPoint(); 167 } 168 169 //===--------------------------------------------------------------------===// 170 // Miscellaneous creation methods. 171 //===--------------------------------------------------------------------===// 172 173 /// CreateGlobalString - Make a new global variable with an initializer that 174 /// has array of i8 type filled in with the nul terminated string value 175 /// specified. The new global variable will be marked mergable with any 176 /// others of the same contents. If Name is specified, it is the name of the 177 /// global variable created. 178 Value *CreateGlobalString(StringRef Str, const Twine &Name = ""); 179 180 /// getInt1 - Get a constant value representing either true or false. 181 ConstantInt *getInt1(bool V) { 182 return ConstantInt::get(getInt1Ty(), V); 183 } 184 185 /// getTrue - Get the constant value for i1 true. 186 ConstantInt *getTrue() { 187 return ConstantInt::getTrue(Context); 188 } 189 190 /// getFalse - Get the constant value for i1 false. 191 ConstantInt *getFalse() { 192 return ConstantInt::getFalse(Context); 193 } 194 195 /// getInt8 - Get a constant 8-bit value. 196 ConstantInt *getInt8(uint8_t C) { 197 return ConstantInt::get(getInt8Ty(), C); 198 } 199 200 /// getInt16 - Get a constant 16-bit value. 201 ConstantInt *getInt16(uint16_t C) { 202 return ConstantInt::get(getInt16Ty(), C); 203 } 204 205 /// getInt32 - Get a constant 32-bit value. 206 ConstantInt *getInt32(uint32_t C) { 207 return ConstantInt::get(getInt32Ty(), C); 208 } 209 210 /// getInt64 - Get a constant 64-bit value. 211 ConstantInt *getInt64(uint64_t C) { 212 return ConstantInt::get(getInt64Ty(), C); 213 } 214 215 /// getInt - Get a constant integer value. 216 ConstantInt *getInt(const APInt &AI) { 217 return ConstantInt::get(Context, AI); 218 } 219 220 //===--------------------------------------------------------------------===// 221 // Type creation methods 222 //===--------------------------------------------------------------------===// 223 224 /// getInt1Ty - Fetch the type representing a single bit 225 IntegerType *getInt1Ty() { 226 return Type::getInt1Ty(Context); 227 } 228 229 /// getInt8Ty - Fetch the type representing an 8-bit integer. 230 IntegerType *getInt8Ty() { 231 return Type::getInt8Ty(Context); 232 } 233 234 /// getInt16Ty - Fetch the type representing a 16-bit integer. 235 IntegerType *getInt16Ty() { 236 return Type::getInt16Ty(Context); 237 } 238 239 /// getInt32Ty - Fetch the type resepresenting a 32-bit integer. 240 IntegerType *getInt32Ty() { 241 return Type::getInt32Ty(Context); 242 } 243 244 /// getInt64Ty - Fetch the type representing a 64-bit integer. 245 IntegerType *getInt64Ty() { 246 return Type::getInt64Ty(Context); 247 } 248 249 /// getFloatTy - Fetch the type representing a 32-bit floating point value. 250 Type *getFloatTy() { 251 return Type::getFloatTy(Context); 252 } 253 254 /// getDoubleTy - Fetch the type representing a 64-bit floating point value. 255 Type *getDoubleTy() { 256 return Type::getDoubleTy(Context); 257 } 258 259 /// getVoidTy - Fetch the type representing void. 260 Type *getVoidTy() { 261 return Type::getVoidTy(Context); 262 } 263 264 PointerType *getInt8PtrTy(unsigned AddrSpace = 0) { 265 return Type::getInt8PtrTy(Context, AddrSpace); 266 } 267 268 //===--------------------------------------------------------------------===// 269 // Intrinsic creation methods 270 //===--------------------------------------------------------------------===// 271 272 /// CreateMemSet - Create and insert a memset to the specified pointer and the 273 /// specified value. If the pointer isn't an i8*, it will be converted. If a 274 /// TBAA tag is specified, it will be added to the instruction. 275 CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align, 276 bool isVolatile = false, MDNode *TBAATag = 0) { 277 return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile, TBAATag); 278 } 279 280 CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align, 281 bool isVolatile = false, MDNode *TBAATag = 0); 282 283 /// CreateMemCpy - Create and insert a memcpy between the specified pointers. 284 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is 285 /// specified, it will be added to the instruction. 286 CallInst *CreateMemCpy(Value *Dst, Value *Src, uint64_t Size, unsigned Align, 287 bool isVolatile = false, MDNode *TBAATag = 0) { 288 return CreateMemCpy(Dst, Src, getInt64(Size), Align, isVolatile, TBAATag); 289 } 290 291 CallInst *CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align, 292 bool isVolatile = false, MDNode *TBAATag = 0); 293 294 /// CreateMemMove - Create and insert a memmove between the specified 295 /// pointers. If the pointers aren't i8*, they will be converted. If a TBAA 296 /// tag is specified, it will be added to the instruction. 297 CallInst *CreateMemMove(Value *Dst, Value *Src, uint64_t Size, unsigned Align, 298 bool isVolatile = false, MDNode *TBAATag = 0) { 299 return CreateMemMove(Dst, Src, getInt64(Size), Align, isVolatile, TBAATag); 300 } 301 302 CallInst *CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align, 303 bool isVolatile = false, MDNode *TBAATag = 0); 304 305 /// CreateLifetimeStart - Create a lifetime.start intrinsic. If the pointer 306 /// isn't i8* it will be converted. 307 CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = 0); 308 309 /// CreateLifetimeEnd - Create a lifetime.end intrinsic. If the pointer isn't 310 /// i8* it will be converted. 311 CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = 0); 312 313 private: 314 Value *getCastedInt8PtrValue(Value *Ptr); 315 }; 316 317 /// IRBuilder - This provides a uniform API for creating instructions and 318 /// inserting them into a basic block: either at the end of a BasicBlock, or 319 /// at a specific iterator location in a block. 320 /// 321 /// Note that the builder does not expose the full generality of LLVM 322 /// instructions. For access to extra instruction properties, use the mutators 323 /// (e.g. setVolatile) on the instructions after they have been created. 324 /// The first template argument handles whether or not to preserve names in the 325 /// final instruction output. This defaults to on. The second template argument 326 /// specifies a class to use for creating constants. This defaults to creating 327 /// minimally folded constants. The fourth template argument allows clients to 328 /// specify custom insertion hooks that are called on every newly created 329 /// insertion. 330 template<bool preserveNames = true, typename T = ConstantFolder, 331 typename Inserter = IRBuilderDefaultInserter<preserveNames> > 332 class IRBuilder : public IRBuilderBase, public Inserter { 333 T Folder; 334 public: 335 IRBuilder(LLVMContext &C, const T &F, const Inserter &I = Inserter()) 336 : IRBuilderBase(C), Inserter(I), Folder(F) { 337 } 338 339 explicit IRBuilder(LLVMContext &C) : IRBuilderBase(C), Folder() { 340 } 341 342 explicit IRBuilder(BasicBlock *TheBB, const T &F) 343 : IRBuilderBase(TheBB->getContext()), Folder(F) { 344 SetInsertPoint(TheBB); 345 } 346 347 explicit IRBuilder(BasicBlock *TheBB) 348 : IRBuilderBase(TheBB->getContext()), Folder() { 349 SetInsertPoint(TheBB); 350 } 351 352 explicit IRBuilder(Instruction *IP) 353 : IRBuilderBase(IP->getContext()), Folder() { 354 SetInsertPoint(IP); 355 SetCurrentDebugLocation(IP->getDebugLoc()); 356 } 357 358 explicit IRBuilder(Use &U) 359 : IRBuilderBase(U->getContext()), Folder() { 360 SetInsertPoint(U); 361 SetCurrentDebugLocation(cast<Instruction>(U.getUser())->getDebugLoc()); 362 } 363 364 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T& F) 365 : IRBuilderBase(TheBB->getContext()), Folder(F) { 366 SetInsertPoint(TheBB, IP); 367 } 368 369 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) 370 : IRBuilderBase(TheBB->getContext()), Folder() { 371 SetInsertPoint(TheBB, IP); 372 } 373 374 /// getFolder - Get the constant folder being used. 375 const T &getFolder() { return Folder; } 376 377 /// isNamePreserving - Return true if this builder is configured to actually 378 /// add the requested names to IR created through it. 379 bool isNamePreserving() const { return preserveNames; } 380 381 /// Insert - Insert and return the specified instruction. 382 template<typename InstTy> 383 InstTy *Insert(InstTy *I, const Twine &Name = "") const { 384 this->InsertHelper(I, Name, BB, InsertPt); 385 if (!getCurrentDebugLocation().isUnknown()) 386 this->SetInstDebugLocation(I); 387 return I; 388 } 389 390 /// Insert - No-op overload to handle constants. 391 Constant *Insert(Constant *C, const Twine& = "") const { 392 return C; 393 } 394 395 //===--------------------------------------------------------------------===// 396 // Instruction creation methods: Terminators 397 //===--------------------------------------------------------------------===// 398 399 /// CreateRetVoid - Create a 'ret void' instruction. 400 ReturnInst *CreateRetVoid() { 401 return Insert(ReturnInst::Create(Context)); 402 } 403 404 /// @verbatim 405 /// CreateRet - Create a 'ret <val>' instruction. 406 /// @endverbatim 407 ReturnInst *CreateRet(Value *V) { 408 return Insert(ReturnInst::Create(Context, V)); 409 } 410 411 /// CreateAggregateRet - Create a sequence of N insertvalue instructions, 412 /// with one Value from the retVals array each, that build a aggregate 413 /// return value one value at a time, and a ret instruction to return 414 /// the resulting aggregate value. This is a convenience function for 415 /// code that uses aggregate return values as a vehicle for having 416 /// multiple return values. 417 /// 418 ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) { 419 Value *V = UndefValue::get(getCurrentFunctionReturnType()); 420 for (unsigned i = 0; i != N; ++i) 421 V = CreateInsertValue(V, retVals[i], i, "mrv"); 422 return Insert(ReturnInst::Create(Context, V)); 423 } 424 425 /// CreateBr - Create an unconditional 'br label X' instruction. 426 BranchInst *CreateBr(BasicBlock *Dest) { 427 return Insert(BranchInst::Create(Dest)); 428 } 429 430 /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest' 431 /// instruction. 432 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) { 433 return Insert(BranchInst::Create(True, False, Cond)); 434 } 435 436 /// CreateSwitch - Create a switch instruction with the specified value, 437 /// default dest, and with a hint for the number of cases that will be added 438 /// (for efficient allocation). 439 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) { 440 return Insert(SwitchInst::Create(V, Dest, NumCases)); 441 } 442 443 /// CreateIndirectBr - Create an indirect branch instruction with the 444 /// specified address operand, with an optional hint for the number of 445 /// destinations that will be added (for efficient allocation). 446 IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) { 447 return Insert(IndirectBrInst::Create(Addr, NumDests)); 448 } 449 450 InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, 451 BasicBlock *UnwindDest, const Twine &Name = "") { 452 return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, 453 ArrayRef<Value *>()), 454 Name); 455 } 456 InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, 457 BasicBlock *UnwindDest, Value *Arg1, 458 const Twine &Name = "") { 459 return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Arg1), 460 Name); 461 } 462 InvokeInst *CreateInvoke3(Value *Callee, BasicBlock *NormalDest, 463 BasicBlock *UnwindDest, Value *Arg1, 464 Value *Arg2, Value *Arg3, 465 const Twine &Name = "") { 466 Value *Args[] = { Arg1, Arg2, Arg3 }; 467 return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args), 468 Name); 469 } 470 /// CreateInvoke - Create an invoke instruction. 471 InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, 472 BasicBlock *UnwindDest, ArrayRef<Value *> Args, 473 const Twine &Name = "") { 474 return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args), 475 Name); 476 } 477 478 UnwindInst *CreateUnwind() { 479 return Insert(new UnwindInst(Context)); 480 } 481 482 UnreachableInst *CreateUnreachable() { 483 return Insert(new UnreachableInst(Context)); 484 } 485 486 //===--------------------------------------------------------------------===// 487 // Instruction creation methods: Binary Operators 488 //===--------------------------------------------------------------------===// 489 private: 490 BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc, 491 Value *LHS, Value *RHS, 492 const Twine &Name, 493 bool HasNUW, bool HasNSW) { 494 BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name); 495 if (HasNUW) BO->setHasNoUnsignedWrap(); 496 if (HasNSW) BO->setHasNoSignedWrap(); 497 return BO; 498 } 499 public: 500 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "", 501 bool HasNUW = false, bool HasNSW = false) { 502 if (Constant *LC = dyn_cast<Constant>(LHS)) 503 if (Constant *RC = dyn_cast<Constant>(RHS)) 504 return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name); 505 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name, 506 HasNUW, HasNSW); 507 } 508 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 509 return CreateAdd(LHS, RHS, Name, false, true); 510 } 511 Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 512 return CreateAdd(LHS, RHS, Name, true, false); 513 } 514 Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 515 if (Constant *LC = dyn_cast<Constant>(LHS)) 516 if (Constant *RC = dyn_cast<Constant>(RHS)) 517 return Insert(Folder.CreateFAdd(LC, RC), Name); 518 return Insert(BinaryOperator::CreateFAdd(LHS, RHS), Name); 519 } 520 Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "", 521 bool HasNUW = false, bool HasNSW = false) { 522 if (Constant *LC = dyn_cast<Constant>(LHS)) 523 if (Constant *RC = dyn_cast<Constant>(RHS)) 524 return Insert(Folder.CreateSub(LC, RC), Name); 525 return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name, 526 HasNUW, HasNSW); 527 } 528 Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") { 529 return CreateSub(LHS, RHS, Name, false, true); 530 } 531 Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") { 532 return CreateSub(LHS, RHS, Name, true, false); 533 } 534 Value *CreateFSub(Value *LHS, Value *RHS, const Twine &Name = "") { 535 if (Constant *LC = dyn_cast<Constant>(LHS)) 536 if (Constant *RC = dyn_cast<Constant>(RHS)) 537 return Insert(Folder.CreateFSub(LC, RC), Name); 538 return Insert(BinaryOperator::CreateFSub(LHS, RHS), Name); 539 } 540 Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "", 541 bool HasNUW = false, bool HasNSW = false) { 542 if (Constant *LC = dyn_cast<Constant>(LHS)) 543 if (Constant *RC = dyn_cast<Constant>(RHS)) 544 return Insert(Folder.CreateMul(LC, RC), Name); 545 return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name, 546 HasNUW, HasNSW); 547 } 548 Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") { 549 return CreateMul(LHS, RHS, Name, false, true); 550 } 551 Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") { 552 return CreateMul(LHS, RHS, Name, true, false); 553 } 554 Value *CreateFMul(Value *LHS, Value *RHS, const Twine &Name = "") { 555 if (Constant *LC = dyn_cast<Constant>(LHS)) 556 if (Constant *RC = dyn_cast<Constant>(RHS)) 557 return Insert(Folder.CreateFMul(LC, RC), Name); 558 return Insert(BinaryOperator::CreateFMul(LHS, RHS), Name); 559 } 560 Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "", 561 bool isExact = false) { 562 if (Constant *LC = dyn_cast<Constant>(LHS)) 563 if (Constant *RC = dyn_cast<Constant>(RHS)) 564 return Insert(Folder.CreateUDiv(LC, RC, isExact), Name); 565 if (!isExact) 566 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name); 567 return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name); 568 } 569 Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 570 return CreateUDiv(LHS, RHS, Name, true); 571 } 572 Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "", 573 bool isExact = false) { 574 if (Constant *LC = dyn_cast<Constant>(LHS)) 575 if (Constant *RC = dyn_cast<Constant>(RHS)) 576 return Insert(Folder.CreateSDiv(LC, RC, isExact), Name); 577 if (!isExact) 578 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name); 579 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name); 580 } 581 Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 582 return CreateSDiv(LHS, RHS, Name, true); 583 } 584 Value *CreateFDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 585 if (Constant *LC = dyn_cast<Constant>(LHS)) 586 if (Constant *RC = dyn_cast<Constant>(RHS)) 587 return Insert(Folder.CreateFDiv(LC, RC), Name); 588 return Insert(BinaryOperator::CreateFDiv(LHS, RHS), Name); 589 } 590 Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") { 591 if (Constant *LC = dyn_cast<Constant>(LHS)) 592 if (Constant *RC = dyn_cast<Constant>(RHS)) 593 return Insert(Folder.CreateURem(LC, RC), Name); 594 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name); 595 } 596 Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") { 597 if (Constant *LC = dyn_cast<Constant>(LHS)) 598 if (Constant *RC = dyn_cast<Constant>(RHS)) 599 return Insert(Folder.CreateSRem(LC, RC), Name); 600 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name); 601 } 602 Value *CreateFRem(Value *LHS, Value *RHS, const Twine &Name = "") { 603 if (Constant *LC = dyn_cast<Constant>(LHS)) 604 if (Constant *RC = dyn_cast<Constant>(RHS)) 605 return Insert(Folder.CreateFRem(LC, RC), Name); 606 return Insert(BinaryOperator::CreateFRem(LHS, RHS), Name); 607 } 608 609 Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "", 610 bool HasNUW = false, bool HasNSW = false) { 611 if (Constant *LC = dyn_cast<Constant>(LHS)) 612 if (Constant *RC = dyn_cast<Constant>(RHS)) 613 return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name); 614 return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name, 615 HasNUW, HasNSW); 616 } 617 Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "", 618 bool HasNUW = false, bool HasNSW = false) { 619 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name, 620 HasNUW, HasNSW); 621 } 622 Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "", 623 bool HasNUW = false, bool HasNSW = false) { 624 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name, 625 HasNUW, HasNSW); 626 } 627 628 Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "", 629 bool isExact = false) { 630 if (Constant *LC = dyn_cast<Constant>(LHS)) 631 if (Constant *RC = dyn_cast<Constant>(RHS)) 632 return Insert(Folder.CreateLShr(LC, RC, isExact), Name); 633 if (!isExact) 634 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name); 635 return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name); 636 } 637 Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "", 638 bool isExact = false) { 639 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 640 } 641 Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "", 642 bool isExact = false) { 643 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 644 } 645 646 Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "", 647 bool isExact = false) { 648 if (Constant *LC = dyn_cast<Constant>(LHS)) 649 if (Constant *RC = dyn_cast<Constant>(RHS)) 650 return Insert(Folder.CreateAShr(LC, RC, isExact), Name); 651 if (!isExact) 652 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name); 653 return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name); 654 } 655 Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "", 656 bool isExact = false) { 657 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 658 } 659 Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "", 660 bool isExact = false) { 661 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 662 } 663 664 Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") { 665 if (Constant *RC = dyn_cast<Constant>(RHS)) { 666 if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isAllOnesValue()) 667 return LHS; // LHS & -1 -> LHS 668 if (Constant *LC = dyn_cast<Constant>(LHS)) 669 return Insert(Folder.CreateAnd(LC, RC), Name); 670 } 671 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name); 672 } 673 Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") { 674 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 675 } 676 Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") { 677 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 678 } 679 680 Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") { 681 if (Constant *RC = dyn_cast<Constant>(RHS)) { 682 if (RC->isNullValue()) 683 return LHS; // LHS | 0 -> LHS 684 if (Constant *LC = dyn_cast<Constant>(LHS)) 685 return Insert(Folder.CreateOr(LC, RC), Name); 686 } 687 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name); 688 } 689 Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") { 690 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 691 } 692 Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") { 693 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 694 } 695 696 Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") { 697 if (Constant *LC = dyn_cast<Constant>(LHS)) 698 if (Constant *RC = dyn_cast<Constant>(RHS)) 699 return Insert(Folder.CreateXor(LC, RC), Name); 700 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name); 701 } 702 Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") { 703 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 704 } 705 Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") { 706 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 707 } 708 709 Value *CreateBinOp(Instruction::BinaryOps Opc, 710 Value *LHS, Value *RHS, const Twine &Name = "") { 711 if (Constant *LC = dyn_cast<Constant>(LHS)) 712 if (Constant *RC = dyn_cast<Constant>(RHS)) 713 return Insert(Folder.CreateBinOp(Opc, LC, RC), Name); 714 return Insert(BinaryOperator::Create(Opc, LHS, RHS), Name); 715 } 716 717 Value *CreateNeg(Value *V, const Twine &Name = "", 718 bool HasNUW = false, bool HasNSW = false) { 719 if (Constant *VC = dyn_cast<Constant>(V)) 720 return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name); 721 BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name); 722 if (HasNUW) BO->setHasNoUnsignedWrap(); 723 if (HasNSW) BO->setHasNoSignedWrap(); 724 return BO; 725 } 726 Value *CreateNSWNeg(Value *V, const Twine &Name = "") { 727 return CreateNeg(V, Name, false, true); 728 } 729 Value *CreateNUWNeg(Value *V, const Twine &Name = "") { 730 return CreateNeg(V, Name, true, false); 731 } 732 Value *CreateFNeg(Value *V, const Twine &Name = "") { 733 if (Constant *VC = dyn_cast<Constant>(V)) 734 return Insert(Folder.CreateFNeg(VC), Name); 735 return Insert(BinaryOperator::CreateFNeg(V), Name); 736 } 737 Value *CreateNot(Value *V, const Twine &Name = "") { 738 if (Constant *VC = dyn_cast<Constant>(V)) 739 return Insert(Folder.CreateNot(VC), Name); 740 return Insert(BinaryOperator::CreateNot(V), Name); 741 } 742 743 //===--------------------------------------------------------------------===// 744 // Instruction creation methods: Memory Instructions 745 //===--------------------------------------------------------------------===// 746 747 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = 0, 748 const Twine &Name = "") { 749 return Insert(new AllocaInst(Ty, ArraySize), Name); 750 } 751 // Provided to resolve 'CreateLoad(Ptr, "...")' correctly, instead of 752 // converting the string to 'bool' for the isVolatile parameter. 753 LoadInst *CreateLoad(Value *Ptr, const char *Name) { 754 return Insert(new LoadInst(Ptr), Name); 755 } 756 LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") { 757 return Insert(new LoadInst(Ptr), Name); 758 } 759 LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") { 760 return Insert(new LoadInst(Ptr, 0, isVolatile), Name); 761 } 762 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) { 763 return Insert(new StoreInst(Val, Ptr, isVolatile)); 764 } 765 template<typename RandomAccessIterator> 766 Value *CreateGEP(Value *Ptr, 767 RandomAccessIterator IdxBegin, 768 RandomAccessIterator IdxEnd, 769 const Twine &Name = "") { 770 if (Constant *PC = dyn_cast<Constant>(Ptr)) { 771 // Every index must be constant. 772 RandomAccessIterator i; 773 for (i = IdxBegin; i < IdxEnd; ++i) 774 if (!isa<Constant>(*i)) 775 break; 776 if (i == IdxEnd) 777 return Insert(Folder.CreateGetElementPtr(PC, &IdxBegin[0], 778 IdxEnd - IdxBegin), 779 Name); 780 } 781 return Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd), Name); 782 } 783 template<typename RandomAccessIterator> 784 Value *CreateInBoundsGEP(Value *Ptr, RandomAccessIterator IdxBegin, 785 RandomAccessIterator IdxEnd, 786 const Twine &Name = "") { 787 if (Constant *PC = dyn_cast<Constant>(Ptr)) { 788 // Every index must be constant. 789 RandomAccessIterator i; 790 for (i = IdxBegin; i < IdxEnd; ++i) 791 if (!isa<Constant>(*i)) 792 break; 793 if (i == IdxEnd) 794 return Insert(Folder.CreateInBoundsGetElementPtr(PC, 795 &IdxBegin[0], 796 IdxEnd - IdxBegin), 797 Name); 798 } 799 return Insert(GetElementPtrInst::CreateInBounds(Ptr, IdxBegin, IdxEnd), 800 Name); 801 } 802 Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") { 803 if (Constant *PC = dyn_cast<Constant>(Ptr)) 804 if (Constant *IC = dyn_cast<Constant>(Idx)) 805 return Insert(Folder.CreateGetElementPtr(PC, &IC, 1), Name); 806 return Insert(GetElementPtrInst::Create(Ptr, Idx), Name); 807 } 808 Value *CreateInBoundsGEP(Value *Ptr, Value *Idx, const Twine &Name = "") { 809 if (Constant *PC = dyn_cast<Constant>(Ptr)) 810 if (Constant *IC = dyn_cast<Constant>(Idx)) 811 return Insert(Folder.CreateInBoundsGetElementPtr(PC, &IC, 1), Name); 812 return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idx), Name); 813 } 814 Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") { 815 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0); 816 817 if (Constant *PC = dyn_cast<Constant>(Ptr)) 818 return Insert(Folder.CreateGetElementPtr(PC, &Idx, 1), Name); 819 820 return Insert(GetElementPtrInst::Create(Ptr, &Idx, &Idx+1), Name); 821 } 822 Value *CreateConstInBoundsGEP1_32(Value *Ptr, unsigned Idx0, 823 const Twine &Name = "") { 824 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0); 825 826 if (Constant *PC = dyn_cast<Constant>(Ptr)) 827 return Insert(Folder.CreateInBoundsGetElementPtr(PC, &Idx, 1), Name); 828 829 return Insert(GetElementPtrInst::CreateInBounds(Ptr, &Idx, &Idx+1), Name); 830 } 831 Value *CreateConstGEP2_32(Value *Ptr, unsigned Idx0, unsigned Idx1, 832 const Twine &Name = "") { 833 Value *Idxs[] = { 834 ConstantInt::get(Type::getInt32Ty(Context), Idx0), 835 ConstantInt::get(Type::getInt32Ty(Context), Idx1) 836 }; 837 838 if (Constant *PC = dyn_cast<Constant>(Ptr)) 839 return Insert(Folder.CreateGetElementPtr(PC, Idxs, 2), Name); 840 841 return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2), Name); 842 } 843 Value *CreateConstInBoundsGEP2_32(Value *Ptr, unsigned Idx0, unsigned Idx1, 844 const Twine &Name = "") { 845 Value *Idxs[] = { 846 ConstantInt::get(Type::getInt32Ty(Context), Idx0), 847 ConstantInt::get(Type::getInt32Ty(Context), Idx1) 848 }; 849 850 if (Constant *PC = dyn_cast<Constant>(Ptr)) 851 return Insert(Folder.CreateInBoundsGetElementPtr(PC, Idxs, 2), Name); 852 853 return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idxs, Idxs+2), Name); 854 } 855 Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") { 856 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0); 857 858 if (Constant *PC = dyn_cast<Constant>(Ptr)) 859 return Insert(Folder.CreateGetElementPtr(PC, &Idx, 1), Name); 860 861 return Insert(GetElementPtrInst::Create(Ptr, &Idx, &Idx+1), Name); 862 } 863 Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0, 864 const Twine &Name = "") { 865 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0); 866 867 if (Constant *PC = dyn_cast<Constant>(Ptr)) 868 return Insert(Folder.CreateInBoundsGetElementPtr(PC, &Idx, 1), Name); 869 870 return Insert(GetElementPtrInst::CreateInBounds(Ptr, &Idx, &Idx+1), Name); 871 } 872 Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, 873 const Twine &Name = "") { 874 Value *Idxs[] = { 875 ConstantInt::get(Type::getInt64Ty(Context), Idx0), 876 ConstantInt::get(Type::getInt64Ty(Context), Idx1) 877 }; 878 879 if (Constant *PC = dyn_cast<Constant>(Ptr)) 880 return Insert(Folder.CreateGetElementPtr(PC, Idxs, 2), Name); 881 882 return Insert(GetElementPtrInst::Create(Ptr, Idxs, Idxs+2), Name); 883 } 884 Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, 885 const Twine &Name = "") { 886 Value *Idxs[] = { 887 ConstantInt::get(Type::getInt64Ty(Context), Idx0), 888 ConstantInt::get(Type::getInt64Ty(Context), Idx1) 889 }; 890 891 if (Constant *PC = dyn_cast<Constant>(Ptr)) 892 return Insert(Folder.CreateInBoundsGetElementPtr(PC, Idxs, 2), Name); 893 894 return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idxs, Idxs+2), Name); 895 } 896 Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") { 897 return CreateConstInBoundsGEP2_32(Ptr, 0, Idx, Name); 898 } 899 900 /// CreateGlobalStringPtr - Same as CreateGlobalString, but return a pointer 901 /// with "i8*" type instead of a pointer to array of i8. 902 Value *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "") { 903 Value *gv = CreateGlobalString(Str, Name); 904 Value *zero = ConstantInt::get(Type::getInt32Ty(Context), 0); 905 Value *Args[] = { zero, zero }; 906 return CreateInBoundsGEP(gv, Args, Args+2, Name); 907 } 908 909 //===--------------------------------------------------------------------===// 910 // Instruction creation methods: Cast/Conversion Operators 911 //===--------------------------------------------------------------------===// 912 913 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") { 914 return CreateCast(Instruction::Trunc, V, DestTy, Name); 915 } 916 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") { 917 return CreateCast(Instruction::ZExt, V, DestTy, Name); 918 } 919 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") { 920 return CreateCast(Instruction::SExt, V, DestTy, Name); 921 } 922 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = ""){ 923 return CreateCast(Instruction::FPToUI, V, DestTy, Name); 924 } 925 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = ""){ 926 return CreateCast(Instruction::FPToSI, V, DestTy, Name); 927 } 928 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){ 929 return CreateCast(Instruction::UIToFP, V, DestTy, Name); 930 } 931 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){ 932 return CreateCast(Instruction::SIToFP, V, DestTy, Name); 933 } 934 Value *CreateFPTrunc(Value *V, Type *DestTy, 935 const Twine &Name = "") { 936 return CreateCast(Instruction::FPTrunc, V, DestTy, Name); 937 } 938 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") { 939 return CreateCast(Instruction::FPExt, V, DestTy, Name); 940 } 941 Value *CreatePtrToInt(Value *V, Type *DestTy, 942 const Twine &Name = "") { 943 return CreateCast(Instruction::PtrToInt, V, DestTy, Name); 944 } 945 Value *CreateIntToPtr(Value *V, Type *DestTy, 946 const Twine &Name = "") { 947 return CreateCast(Instruction::IntToPtr, V, DestTy, Name); 948 } 949 Value *CreateBitCast(Value *V, Type *DestTy, 950 const Twine &Name = "") { 951 return CreateCast(Instruction::BitCast, V, DestTy, Name); 952 } 953 Value *CreateZExtOrBitCast(Value *V, Type *DestTy, 954 const Twine &Name = "") { 955 if (V->getType() == DestTy) 956 return V; 957 if (Constant *VC = dyn_cast<Constant>(V)) 958 return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name); 959 return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name); 960 } 961 Value *CreateSExtOrBitCast(Value *V, Type *DestTy, 962 const Twine &Name = "") { 963 if (V->getType() == DestTy) 964 return V; 965 if (Constant *VC = dyn_cast<Constant>(V)) 966 return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name); 967 return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name); 968 } 969 Value *CreateTruncOrBitCast(Value *V, Type *DestTy, 970 const Twine &Name = "") { 971 if (V->getType() == DestTy) 972 return V; 973 if (Constant *VC = dyn_cast<Constant>(V)) 974 return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name); 975 return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name); 976 } 977 Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, 978 const Twine &Name = "") { 979 if (V->getType() == DestTy) 980 return V; 981 if (Constant *VC = dyn_cast<Constant>(V)) 982 return Insert(Folder.CreateCast(Op, VC, DestTy), Name); 983 return Insert(CastInst::Create(Op, V, DestTy), Name); 984 } 985 Value *CreatePointerCast(Value *V, Type *DestTy, 986 const Twine &Name = "") { 987 if (V->getType() == DestTy) 988 return V; 989 if (Constant *VC = dyn_cast<Constant>(V)) 990 return Insert(Folder.CreatePointerCast(VC, DestTy), Name); 991 return Insert(CastInst::CreatePointerCast(V, DestTy), Name); 992 } 993 Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned, 994 const Twine &Name = "") { 995 if (V->getType() == DestTy) 996 return V; 997 if (Constant *VC = dyn_cast<Constant>(V)) 998 return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name); 999 return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name); 1000 } 1001 private: 1002 // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a compile time 1003 // error, instead of converting the string to bool for the isSigned parameter. 1004 Value *CreateIntCast(Value *, Type *, const char *); // DO NOT IMPLEMENT 1005 public: 1006 Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") { 1007 if (V->getType() == DestTy) 1008 return V; 1009 if (Constant *VC = dyn_cast<Constant>(V)) 1010 return Insert(Folder.CreateFPCast(VC, DestTy), Name); 1011 return Insert(CastInst::CreateFPCast(V, DestTy), Name); 1012 } 1013 1014 //===--------------------------------------------------------------------===// 1015 // Instruction creation methods: Compare Instructions 1016 //===--------------------------------------------------------------------===// 1017 1018 Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 1019 return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name); 1020 } 1021 Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") { 1022 return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name); 1023 } 1024 Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") { 1025 return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name); 1026 } 1027 Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") { 1028 return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name); 1029 } 1030 Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") { 1031 return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name); 1032 } 1033 Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") { 1034 return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name); 1035 } 1036 Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") { 1037 return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name); 1038 } 1039 Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") { 1040 return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name); 1041 } 1042 Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") { 1043 return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name); 1044 } 1045 Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") { 1046 return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name); 1047 } 1048 1049 Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 1050 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name); 1051 } 1052 Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "") { 1053 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name); 1054 } 1055 Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "") { 1056 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name); 1057 } 1058 Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "") { 1059 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name); 1060 } 1061 Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "") { 1062 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name); 1063 } 1064 Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "") { 1065 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name); 1066 } 1067 Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "") { 1068 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name); 1069 } 1070 Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "") { 1071 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name); 1072 } 1073 Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 1074 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name); 1075 } 1076 Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") { 1077 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name); 1078 } 1079 Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") { 1080 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name); 1081 } 1082 Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "") { 1083 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name); 1084 } 1085 Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "") { 1086 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name); 1087 } 1088 Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "") { 1089 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name); 1090 } 1091 1092 Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, 1093 const Twine &Name = "") { 1094 if (Constant *LC = dyn_cast<Constant>(LHS)) 1095 if (Constant *RC = dyn_cast<Constant>(RHS)) 1096 return Insert(Folder.CreateICmp(P, LC, RC), Name); 1097 return Insert(new ICmpInst(P, LHS, RHS), Name); 1098 } 1099 Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, 1100 const Twine &Name = "") { 1101 if (Constant *LC = dyn_cast<Constant>(LHS)) 1102 if (Constant *RC = dyn_cast<Constant>(RHS)) 1103 return Insert(Folder.CreateFCmp(P, LC, RC), Name); 1104 return Insert(new FCmpInst(P, LHS, RHS), Name); 1105 } 1106 1107 //===--------------------------------------------------------------------===// 1108 // Instruction creation methods: Other Instructions 1109 //===--------------------------------------------------------------------===// 1110 1111 PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues, 1112 const Twine &Name = "") { 1113 return Insert(PHINode::Create(Ty, NumReservedValues), Name); 1114 } 1115 1116 CallInst *CreateCall(Value *Callee, const Twine &Name = "") { 1117 return Insert(CallInst::Create(Callee), Name); 1118 } 1119 CallInst *CreateCall(Value *Callee, Value *Arg, const Twine &Name = "") { 1120 return Insert(CallInst::Create(Callee, Arg), Name); 1121 } 1122 CallInst *CreateCall2(Value *Callee, Value *Arg1, Value *Arg2, 1123 const Twine &Name = "") { 1124 Value *Args[] = { Arg1, Arg2 }; 1125 return Insert(CallInst::Create(Callee, Args), Name); 1126 } 1127 CallInst *CreateCall3(Value *Callee, Value *Arg1, Value *Arg2, Value *Arg3, 1128 const Twine &Name = "") { 1129 Value *Args[] = { Arg1, Arg2, Arg3 }; 1130 return Insert(CallInst::Create(Callee, Args), Name); 1131 } 1132 CallInst *CreateCall4(Value *Callee, Value *Arg1, Value *Arg2, Value *Arg3, 1133 Value *Arg4, const Twine &Name = "") { 1134 Value *Args[] = { Arg1, Arg2, Arg3, Arg4 }; 1135 return Insert(CallInst::Create(Callee, Args), Name); 1136 } 1137 CallInst *CreateCall5(Value *Callee, Value *Arg1, Value *Arg2, Value *Arg3, 1138 Value *Arg4, Value *Arg5, const Twine &Name = "") { 1139 Value *Args[] = { Arg1, Arg2, Arg3, Arg4, Arg5 }; 1140 return Insert(CallInst::Create(Callee, Args), Name); 1141 } 1142 1143 CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args, 1144 const Twine &Name = "") { 1145 return Insert(CallInst::Create(Callee, Args, Name)); 1146 } 1147 1148 Value *CreateSelect(Value *C, Value *True, Value *False, 1149 const Twine &Name = "") { 1150 if (Constant *CC = dyn_cast<Constant>(C)) 1151 if (Constant *TC = dyn_cast<Constant>(True)) 1152 if (Constant *FC = dyn_cast<Constant>(False)) 1153 return Insert(Folder.CreateSelect(CC, TC, FC), Name); 1154 return Insert(SelectInst::Create(C, True, False), Name); 1155 } 1156 1157 VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") { 1158 return Insert(new VAArgInst(List, Ty), Name); 1159 } 1160 1161 Value *CreateExtractElement(Value *Vec, Value *Idx, 1162 const Twine &Name = "") { 1163 if (Constant *VC = dyn_cast<Constant>(Vec)) 1164 if (Constant *IC = dyn_cast<Constant>(Idx)) 1165 return Insert(Folder.CreateExtractElement(VC, IC), Name); 1166 return Insert(ExtractElementInst::Create(Vec, Idx), Name); 1167 } 1168 1169 Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, 1170 const Twine &Name = "") { 1171 if (Constant *VC = dyn_cast<Constant>(Vec)) 1172 if (Constant *NC = dyn_cast<Constant>(NewElt)) 1173 if (Constant *IC = dyn_cast<Constant>(Idx)) 1174 return Insert(Folder.CreateInsertElement(VC, NC, IC), Name); 1175 return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name); 1176 } 1177 1178 Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask, 1179 const Twine &Name = "") { 1180 if (Constant *V1C = dyn_cast<Constant>(V1)) 1181 if (Constant *V2C = dyn_cast<Constant>(V2)) 1182 if (Constant *MC = dyn_cast<Constant>(Mask)) 1183 return Insert(Folder.CreateShuffleVector(V1C, V2C, MC), Name); 1184 return Insert(new ShuffleVectorInst(V1, V2, Mask), Name); 1185 } 1186 1187 Value *CreateExtractValue(Value *Agg, 1188 ArrayRef<unsigned> Idxs, 1189 const Twine &Name = "") { 1190 if (Constant *AggC = dyn_cast<Constant>(Agg)) 1191 return Insert(Folder.CreateExtractValue(AggC, Idxs), Name); 1192 return Insert(ExtractValueInst::Create(Agg, Idxs), Name); 1193 } 1194 1195 Value *CreateInsertValue(Value *Agg, Value *Val, 1196 ArrayRef<unsigned> Idxs, 1197 const Twine &Name = "") { 1198 if (Constant *AggC = dyn_cast<Constant>(Agg)) 1199 if (Constant *ValC = dyn_cast<Constant>(Val)) 1200 return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name); 1201 return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name); 1202 } 1203 1204 //===--------------------------------------------------------------------===// 1205 // Utility creation methods 1206 //===--------------------------------------------------------------------===// 1207 1208 /// CreateIsNull - Return an i1 value testing if \arg Arg is null. 1209 Value *CreateIsNull(Value *Arg, const Twine &Name = "") { 1210 return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()), 1211 Name); 1212 } 1213 1214 /// CreateIsNotNull - Return an i1 value testing if \arg Arg is not null. 1215 Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") { 1216 return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()), 1217 Name); 1218 } 1219 1220 /// CreatePtrDiff - Return the i64 difference between two pointer values, 1221 /// dividing out the size of the pointed-to objects. This is intended to 1222 /// implement C-style pointer subtraction. As such, the pointers must be 1223 /// appropriately aligned for their element types and pointing into the 1224 /// same object. 1225 Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") { 1226 assert(LHS->getType() == RHS->getType() && 1227 "Pointer subtraction operand types must match!"); 1228 PointerType *ArgType = cast<PointerType>(LHS->getType()); 1229 Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context)); 1230 Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context)); 1231 Value *Difference = CreateSub(LHS_int, RHS_int); 1232 return CreateExactSDiv(Difference, 1233 ConstantExpr::getSizeOf(ArgType->getElementType()), 1234 Name); 1235 } 1236 }; 1237 1238 } 1239 1240 #endif 1241
