1 //===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the IRBuilder class, which is used as a convenient way 10 // to create LLVM instructions with a consistent and simplified interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_IR_IRBUILDER_H 15 #define LLVM_IR_IRBUILDER_H 16 17 #include "llvm-c/Types.h" 18 #include "llvm/ADT/ArrayRef.h" 19 #include "llvm/ADT/None.h" 20 #include "llvm/ADT/STLExtras.h" 21 #include "llvm/ADT/StringRef.h" 22 #include "llvm/ADT/Twine.h" 23 #include "llvm/IR/BasicBlock.h" 24 #include "llvm/IR/Constant.h" 25 #include "llvm/IR/ConstantFolder.h" 26 #include "llvm/IR/Constants.h" 27 #include "llvm/IR/DataLayout.h" 28 #include "llvm/IR/DebugInfoMetadata.h" 29 #include "llvm/IR/DebugLoc.h" 30 #include "llvm/IR/DerivedTypes.h" 31 #include "llvm/IR/Function.h" 32 #include "llvm/IR/GlobalVariable.h" 33 #include "llvm/IR/InstrTypes.h" 34 #include "llvm/IR/Instruction.h" 35 #include "llvm/IR/Instructions.h" 36 #include "llvm/IR/IntrinsicInst.h" 37 #include "llvm/IR/LLVMContext.h" 38 #include "llvm/IR/Module.h" 39 #include "llvm/IR/Operator.h" 40 #include "llvm/IR/Type.h" 41 #include "llvm/IR/Value.h" 42 #include "llvm/IR/ValueHandle.h" 43 #include "llvm/Support/AtomicOrdering.h" 44 #include "llvm/Support/CBindingWrapping.h" 45 #include "llvm/Support/Casting.h" 46 #include <cassert> 47 #include <cstddef> 48 #include <cstdint> 49 #include <functional> 50 #include <utility> 51 52 namespace llvm { 53 54 class APInt; 55 class MDNode; 56 class Use; 57 58 /// This provides the default implementation of the IRBuilder 59 /// 'InsertHelper' method that is called whenever an instruction is created by 60 /// IRBuilder and needs to be inserted. 61 /// 62 /// By default, this inserts the instruction at the insertion point. 63 class IRBuilderDefaultInserter { 64 public: 65 virtual ~IRBuilderDefaultInserter(); 66 InsertHelper(Instruction * I,const Twine & Name,BasicBlock * BB,BasicBlock::iterator InsertPt)67 virtual void InsertHelper(Instruction *I, const Twine &Name, 68 BasicBlock *BB, 69 BasicBlock::iterator InsertPt) const { 70 if (BB) BB->getInstList().insert(InsertPt, I); 71 I->setName(Name); 72 } 73 }; 74 75 /// Provides an 'InsertHelper' that calls a user-provided callback after 76 /// performing the default insertion. 77 class IRBuilderCallbackInserter : public IRBuilderDefaultInserter { 78 std::function<void(Instruction *)> Callback; 79 80 public: 81 virtual ~IRBuilderCallbackInserter(); 82 IRBuilderCallbackInserter(std::function<void (Instruction *)> Callback)83 IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback) 84 : Callback(std::move(Callback)) {} 85 InsertHelper(Instruction * I,const Twine & Name,BasicBlock * BB,BasicBlock::iterator InsertPt)86 void InsertHelper(Instruction *I, const Twine &Name, 87 BasicBlock *BB, 88 BasicBlock::iterator InsertPt) const override { 89 IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt); 90 Callback(I); 91 } 92 }; 93 94 /// Common base class shared among various IRBuilders. 95 class IRBuilderBase { 96 /// Pairs of (metadata kind, MDNode *) that should be added to all newly 97 /// created instructions, like !dbg metadata. 98 SmallVector<std::pair<unsigned, MDNode *>, 2> MetadataToCopy; 99 100 /// Add or update the an entry (Kind, MD) to MetadataToCopy, if \p MD is not 101 /// null. If \p MD is null, remove the entry with \p Kind. AddOrRemoveMetadataToCopy(unsigned Kind,MDNode * MD)102 void AddOrRemoveMetadataToCopy(unsigned Kind, MDNode *MD) { 103 if (!MD) { 104 erase_if(MetadataToCopy, [Kind](const std::pair<unsigned, MDNode *> &KV) { 105 return KV.first == Kind; 106 }); 107 return; 108 } 109 110 for (auto &KV : MetadataToCopy) 111 if (KV.first == Kind) { 112 KV.second = MD; 113 return; 114 } 115 116 MetadataToCopy.emplace_back(Kind, MD); 117 } 118 119 protected: 120 BasicBlock *BB; 121 BasicBlock::iterator InsertPt; 122 LLVMContext &Context; 123 const IRBuilderFolder &Folder; 124 const IRBuilderDefaultInserter &Inserter; 125 126 MDNode *DefaultFPMathTag; 127 FastMathFlags FMF; 128 129 bool IsFPConstrained; 130 fp::ExceptionBehavior DefaultConstrainedExcept; 131 RoundingMode DefaultConstrainedRounding; 132 133 ArrayRef<OperandBundleDef> DefaultOperandBundles; 134 135 public: IRBuilderBase(LLVMContext & context,const IRBuilderFolder & Folder,const IRBuilderDefaultInserter & Inserter,MDNode * FPMathTag,ArrayRef<OperandBundleDef> OpBundles)136 IRBuilderBase(LLVMContext &context, const IRBuilderFolder &Folder, 137 const IRBuilderDefaultInserter &Inserter, 138 MDNode *FPMathTag, ArrayRef<OperandBundleDef> OpBundles) 139 : Context(context), Folder(Folder), Inserter(Inserter), 140 DefaultFPMathTag(FPMathTag), IsFPConstrained(false), 141 DefaultConstrainedExcept(fp::ebStrict), 142 DefaultConstrainedRounding(RoundingMode::Dynamic), 143 DefaultOperandBundles(OpBundles) { 144 ClearInsertionPoint(); 145 } 146 147 /// Insert and return the specified instruction. 148 template<typename InstTy> 149 InstTy *Insert(InstTy *I, const Twine &Name = "") const { 150 Inserter.InsertHelper(I, Name, BB, InsertPt); 151 AddMetadataToInst(I); 152 return I; 153 } 154 155 /// No-op overload to handle constants. 156 Constant *Insert(Constant *C, const Twine& = "") const { 157 return C; 158 } 159 160 Value *Insert(Value *V, const Twine &Name = "") const { 161 if (Instruction *I = dyn_cast<Instruction>(V)) 162 return Insert(I, Name); 163 assert(isa<Constant>(V)); 164 return V; 165 } 166 167 //===--------------------------------------------------------------------===// 168 // Builder configuration methods 169 //===--------------------------------------------------------------------===// 170 171 /// Clear the insertion point: created instructions will not be 172 /// inserted into a block. ClearInsertionPoint()173 void ClearInsertionPoint() { 174 BB = nullptr; 175 InsertPt = BasicBlock::iterator(); 176 } 177 GetInsertBlock()178 BasicBlock *GetInsertBlock() const { return BB; } GetInsertPoint()179 BasicBlock::iterator GetInsertPoint() const { return InsertPt; } getContext()180 LLVMContext &getContext() const { return Context; } 181 182 /// This specifies that created instructions should be appended to the 183 /// end of the specified block. SetInsertPoint(BasicBlock * TheBB)184 void SetInsertPoint(BasicBlock *TheBB) { 185 BB = TheBB; 186 InsertPt = BB->end(); 187 } 188 189 /// This specifies that created instructions should be inserted before 190 /// the specified instruction. SetInsertPoint(Instruction * I)191 void SetInsertPoint(Instruction *I) { 192 BB = I->getParent(); 193 InsertPt = I->getIterator(); 194 assert(InsertPt != BB->end() && "Can't read debug loc from end()"); 195 SetCurrentDebugLocation(I->getDebugLoc()); 196 } 197 198 /// This specifies that created instructions should be inserted at the 199 /// specified point. SetInsertPoint(BasicBlock * TheBB,BasicBlock::iterator IP)200 void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) { 201 BB = TheBB; 202 InsertPt = IP; 203 if (IP != TheBB->end()) 204 SetCurrentDebugLocation(IP->getDebugLoc()); 205 } 206 207 /// Set location information used by debugging information. SetCurrentDebugLocation(DebugLoc L)208 void SetCurrentDebugLocation(DebugLoc L) { 209 AddOrRemoveMetadataToCopy(LLVMContext::MD_dbg, L.getAsMDNode()); 210 } 211 212 /// Collect metadata with IDs \p MetadataKinds from \p Src which should be 213 /// added to all created instructions. Entries present in MedataDataToCopy but 214 /// not on \p Src will be dropped from MetadataToCopy. CollectMetadataToCopy(Instruction * Src,ArrayRef<unsigned> MetadataKinds)215 void CollectMetadataToCopy(Instruction *Src, 216 ArrayRef<unsigned> MetadataKinds) { 217 for (unsigned K : MetadataKinds) 218 AddOrRemoveMetadataToCopy(K, Src->getMetadata(K)); 219 } 220 221 /// Get location information used by debugging information. getCurrentDebugLocation()222 DebugLoc getCurrentDebugLocation() const { 223 for (auto &KV : MetadataToCopy) 224 if (KV.first == LLVMContext::MD_dbg) 225 return {cast<DILocation>(KV.second)}; 226 227 return {}; 228 } 229 230 /// If this builder has a current debug location, set it on the 231 /// specified instruction. SetInstDebugLocation(Instruction * I)232 void SetInstDebugLocation(Instruction *I) const { 233 for (const auto &KV : MetadataToCopy) 234 if (KV.first == LLVMContext::MD_dbg) { 235 I->setDebugLoc(DebugLoc(KV.second)); 236 return; 237 } 238 } 239 240 /// Add all entries in MetadataToCopy to \p I. AddMetadataToInst(Instruction * I)241 void AddMetadataToInst(Instruction *I) const { 242 for (auto &KV : MetadataToCopy) 243 I->setMetadata(KV.first, KV.second); 244 } 245 246 /// Get the return type of the current function that we're emitting 247 /// into. 248 Type *getCurrentFunctionReturnType() const; 249 250 /// InsertPoint - A saved insertion point. 251 class InsertPoint { 252 BasicBlock *Block = nullptr; 253 BasicBlock::iterator Point; 254 255 public: 256 /// Creates a new insertion point which doesn't point to anything. 257 InsertPoint() = default; 258 259 /// Creates a new insertion point at the given location. InsertPoint(BasicBlock * InsertBlock,BasicBlock::iterator InsertPoint)260 InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint) 261 : Block(InsertBlock), Point(InsertPoint) {} 262 263 /// Returns true if this insert point is set. isSet()264 bool isSet() const { return (Block != nullptr); } 265 getBlock()266 BasicBlock *getBlock() const { return Block; } getPoint()267 BasicBlock::iterator getPoint() const { return Point; } 268 }; 269 270 /// Returns the current insert point. saveIP()271 InsertPoint saveIP() const { 272 return InsertPoint(GetInsertBlock(), GetInsertPoint()); 273 } 274 275 /// Returns the current insert point, clearing it in the process. saveAndClearIP()276 InsertPoint saveAndClearIP() { 277 InsertPoint IP(GetInsertBlock(), GetInsertPoint()); 278 ClearInsertionPoint(); 279 return IP; 280 } 281 282 /// Sets the current insert point to a previously-saved location. restoreIP(InsertPoint IP)283 void restoreIP(InsertPoint IP) { 284 if (IP.isSet()) 285 SetInsertPoint(IP.getBlock(), IP.getPoint()); 286 else 287 ClearInsertionPoint(); 288 } 289 290 /// Get the floating point math metadata being used. getDefaultFPMathTag()291 MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; } 292 293 /// Get the flags to be applied to created floating point ops getFastMathFlags()294 FastMathFlags getFastMathFlags() const { return FMF; } 295 getFastMathFlags()296 FastMathFlags &getFastMathFlags() { return FMF; } 297 298 /// Clear the fast-math flags. clearFastMathFlags()299 void clearFastMathFlags() { FMF.clear(); } 300 301 /// Set the floating point math metadata to be used. setDefaultFPMathTag(MDNode * FPMathTag)302 void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; } 303 304 /// Set the fast-math flags to be used with generated fp-math operators setFastMathFlags(FastMathFlags NewFMF)305 void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; } 306 307 /// Enable/Disable use of constrained floating point math. When 308 /// enabled the CreateF<op>() calls instead create constrained 309 /// floating point intrinsic calls. Fast math flags are unaffected 310 /// by this setting. setIsFPConstrained(bool IsCon)311 void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; } 312 313 /// Query for the use of constrained floating point math getIsFPConstrained()314 bool getIsFPConstrained() { return IsFPConstrained; } 315 316 /// Set the exception handling to be used with constrained floating point setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept)317 void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) { 318 #ifndef NDEBUG 319 Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(NewExcept); 320 assert(ExceptStr.hasValue() && "Garbage strict exception behavior!"); 321 #endif 322 DefaultConstrainedExcept = NewExcept; 323 } 324 325 /// Set the rounding mode handling to be used with constrained floating point setDefaultConstrainedRounding(RoundingMode NewRounding)326 void setDefaultConstrainedRounding(RoundingMode NewRounding) { 327 #ifndef NDEBUG 328 Optional<StringRef> RoundingStr = RoundingModeToStr(NewRounding); 329 assert(RoundingStr.hasValue() && "Garbage strict rounding mode!"); 330 #endif 331 DefaultConstrainedRounding = NewRounding; 332 } 333 334 /// Get the exception handling used with constrained floating point getDefaultConstrainedExcept()335 fp::ExceptionBehavior getDefaultConstrainedExcept() { 336 return DefaultConstrainedExcept; 337 } 338 339 /// Get the rounding mode handling used with constrained floating point getDefaultConstrainedRounding()340 RoundingMode getDefaultConstrainedRounding() { 341 return DefaultConstrainedRounding; 342 } 343 setConstrainedFPFunctionAttr()344 void setConstrainedFPFunctionAttr() { 345 assert(BB && "Must have a basic block to set any function attributes!"); 346 347 Function *F = BB->getParent(); 348 if (!F->hasFnAttribute(Attribute::StrictFP)) { 349 F->addFnAttr(Attribute::StrictFP); 350 } 351 } 352 setConstrainedFPCallAttr(CallBase * I)353 void setConstrainedFPCallAttr(CallBase *I) { 354 I->addAttribute(AttributeList::FunctionIndex, Attribute::StrictFP); 355 } 356 setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles)357 void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) { 358 DefaultOperandBundles = OpBundles; 359 } 360 361 //===--------------------------------------------------------------------===// 362 // RAII helpers. 363 //===--------------------------------------------------------------------===// 364 365 // RAII object that stores the current insertion point and restores it 366 // when the object is destroyed. This includes the debug location. 367 class InsertPointGuard { 368 IRBuilderBase &Builder; 369 AssertingVH<BasicBlock> Block; 370 BasicBlock::iterator Point; 371 DebugLoc DbgLoc; 372 373 public: InsertPointGuard(IRBuilderBase & B)374 InsertPointGuard(IRBuilderBase &B) 375 : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()), 376 DbgLoc(B.getCurrentDebugLocation()) {} 377 378 InsertPointGuard(const InsertPointGuard &) = delete; 379 InsertPointGuard &operator=(const InsertPointGuard &) = delete; 380 ~InsertPointGuard()381 ~InsertPointGuard() { 382 Builder.restoreIP(InsertPoint(Block, Point)); 383 Builder.SetCurrentDebugLocation(DbgLoc); 384 } 385 }; 386 387 // RAII object that stores the current fast math settings and restores 388 // them when the object is destroyed. 389 class FastMathFlagGuard { 390 IRBuilderBase &Builder; 391 FastMathFlags FMF; 392 MDNode *FPMathTag; 393 bool IsFPConstrained; 394 fp::ExceptionBehavior DefaultConstrainedExcept; 395 RoundingMode DefaultConstrainedRounding; 396 397 public: FastMathFlagGuard(IRBuilderBase & B)398 FastMathFlagGuard(IRBuilderBase &B) 399 : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag), 400 IsFPConstrained(B.IsFPConstrained), 401 DefaultConstrainedExcept(B.DefaultConstrainedExcept), 402 DefaultConstrainedRounding(B.DefaultConstrainedRounding) {} 403 404 FastMathFlagGuard(const FastMathFlagGuard &) = delete; 405 FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete; 406 ~FastMathFlagGuard()407 ~FastMathFlagGuard() { 408 Builder.FMF = FMF; 409 Builder.DefaultFPMathTag = FPMathTag; 410 Builder.IsFPConstrained = IsFPConstrained; 411 Builder.DefaultConstrainedExcept = DefaultConstrainedExcept; 412 Builder.DefaultConstrainedRounding = DefaultConstrainedRounding; 413 } 414 }; 415 416 // RAII object that stores the current default operand bundles and restores 417 // them when the object is destroyed. 418 class OperandBundlesGuard { 419 IRBuilderBase &Builder; 420 ArrayRef<OperandBundleDef> DefaultOperandBundles; 421 422 public: OperandBundlesGuard(IRBuilderBase & B)423 OperandBundlesGuard(IRBuilderBase &B) 424 : Builder(B), DefaultOperandBundles(B.DefaultOperandBundles) {} 425 426 OperandBundlesGuard(const OperandBundlesGuard &) = delete; 427 OperandBundlesGuard &operator=(const OperandBundlesGuard &) = delete; 428 ~OperandBundlesGuard()429 ~OperandBundlesGuard() { 430 Builder.DefaultOperandBundles = DefaultOperandBundles; 431 } 432 }; 433 434 435 //===--------------------------------------------------------------------===// 436 // Miscellaneous creation methods. 437 //===--------------------------------------------------------------------===// 438 439 /// Make a new global variable with initializer type i8* 440 /// 441 /// Make a new global variable with an initializer that has array of i8 type 442 /// filled in with the null terminated string value specified. The new global 443 /// variable will be marked mergable with any others of the same contents. If 444 /// Name is specified, it is the name of the global variable created. 445 /// 446 /// If no module is given via \p M, it is take from the insertion point basic 447 /// block. 448 GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "", 449 unsigned AddressSpace = 0, 450 Module *M = nullptr); 451 452 /// Get a constant value representing either true or false. getInt1(bool V)453 ConstantInt *getInt1(bool V) { 454 return ConstantInt::get(getInt1Ty(), V); 455 } 456 457 /// Get the constant value for i1 true. getTrue()458 ConstantInt *getTrue() { 459 return ConstantInt::getTrue(Context); 460 } 461 462 /// Get the constant value for i1 false. getFalse()463 ConstantInt *getFalse() { 464 return ConstantInt::getFalse(Context); 465 } 466 467 /// Get a constant 8-bit value. getInt8(uint8_t C)468 ConstantInt *getInt8(uint8_t C) { 469 return ConstantInt::get(getInt8Ty(), C); 470 } 471 472 /// Get a constant 16-bit value. getInt16(uint16_t C)473 ConstantInt *getInt16(uint16_t C) { 474 return ConstantInt::get(getInt16Ty(), C); 475 } 476 477 /// Get a constant 32-bit value. getInt32(uint32_t C)478 ConstantInt *getInt32(uint32_t C) { 479 return ConstantInt::get(getInt32Ty(), C); 480 } 481 482 /// Get a constant 64-bit value. getInt64(uint64_t C)483 ConstantInt *getInt64(uint64_t C) { 484 return ConstantInt::get(getInt64Ty(), C); 485 } 486 487 /// Get a constant N-bit value, zero extended or truncated from 488 /// a 64-bit value. getIntN(unsigned N,uint64_t C)489 ConstantInt *getIntN(unsigned N, uint64_t C) { 490 return ConstantInt::get(getIntNTy(N), C); 491 } 492 493 /// Get a constant integer value. getInt(const APInt & AI)494 ConstantInt *getInt(const APInt &AI) { 495 return ConstantInt::get(Context, AI); 496 } 497 498 //===--------------------------------------------------------------------===// 499 // Type creation methods 500 //===--------------------------------------------------------------------===// 501 502 /// Fetch the type representing a single bit getInt1Ty()503 IntegerType *getInt1Ty() { 504 return Type::getInt1Ty(Context); 505 } 506 507 /// Fetch the type representing an 8-bit integer. getInt8Ty()508 IntegerType *getInt8Ty() { 509 return Type::getInt8Ty(Context); 510 } 511 512 /// Fetch the type representing a 16-bit integer. getInt16Ty()513 IntegerType *getInt16Ty() { 514 return Type::getInt16Ty(Context); 515 } 516 517 /// Fetch the type representing a 32-bit integer. getInt32Ty()518 IntegerType *getInt32Ty() { 519 return Type::getInt32Ty(Context); 520 } 521 522 /// Fetch the type representing a 64-bit integer. getInt64Ty()523 IntegerType *getInt64Ty() { 524 return Type::getInt64Ty(Context); 525 } 526 527 /// Fetch the type representing a 128-bit integer. getInt128Ty()528 IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); } 529 530 /// Fetch the type representing an N-bit integer. getIntNTy(unsigned N)531 IntegerType *getIntNTy(unsigned N) { 532 return Type::getIntNTy(Context, N); 533 } 534 535 /// Fetch the type representing a 16-bit floating point value. getHalfTy()536 Type *getHalfTy() { 537 return Type::getHalfTy(Context); 538 } 539 540 /// Fetch the type representing a 16-bit brain floating point value. getBFloatTy()541 Type *getBFloatTy() { 542 return Type::getBFloatTy(Context); 543 } 544 545 /// Fetch the type representing a 32-bit floating point value. getFloatTy()546 Type *getFloatTy() { 547 return Type::getFloatTy(Context); 548 } 549 550 /// Fetch the type representing a 64-bit floating point value. getDoubleTy()551 Type *getDoubleTy() { 552 return Type::getDoubleTy(Context); 553 } 554 555 /// Fetch the type representing void. getVoidTy()556 Type *getVoidTy() { 557 return Type::getVoidTy(Context); 558 } 559 560 /// Fetch the type representing a pointer to an 8-bit integer value. 561 PointerType *getInt8PtrTy(unsigned AddrSpace = 0) { 562 return Type::getInt8PtrTy(Context, AddrSpace); 563 } 564 565 /// Fetch the type representing a pointer to an integer value. 566 IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) { 567 return DL.getIntPtrType(Context, AddrSpace); 568 } 569 570 //===--------------------------------------------------------------------===// 571 // Intrinsic creation methods 572 //===--------------------------------------------------------------------===// 573 574 /// Create and insert a memset to the specified pointer and the 575 /// specified value. 576 /// 577 /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is 578 /// specified, it will be added to the instruction. Likewise with alias.scope 579 /// and noalias tags. 580 CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, 581 MaybeAlign Align, bool isVolatile = false, 582 MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr, 583 MDNode *NoAliasTag = nullptr) { 584 return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile, 585 TBAATag, ScopeTag, NoAliasTag); 586 } 587 588 CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align, 589 bool isVolatile = false, MDNode *TBAATag = nullptr, 590 MDNode *ScopeTag = nullptr, 591 MDNode *NoAliasTag = nullptr); 592 593 /// Create and insert an element unordered-atomic memset of the region of 594 /// memory starting at the given pointer to the given value. 595 /// 596 /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is 597 /// specified, it will be added to the instruction. Likewise with alias.scope 598 /// and noalias tags. 599 CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, 600 uint64_t Size, Align Alignment, 601 uint32_t ElementSize, 602 MDNode *TBAATag = nullptr, 603 MDNode *ScopeTag = nullptr, 604 MDNode *NoAliasTag = nullptr) { 605 return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size), 606 Align(Alignment), ElementSize, 607 TBAATag, ScopeTag, NoAliasTag); 608 } 609 610 CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, 611 Value *Size, Align Alignment, 612 uint32_t ElementSize, 613 MDNode *TBAATag = nullptr, 614 MDNode *ScopeTag = nullptr, 615 MDNode *NoAliasTag = nullptr); 616 617 /// Create and insert a memcpy between the specified pointers. 618 /// 619 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is 620 /// specified, it will be added to the instruction. Likewise with alias.scope 621 /// and noalias tags. 622 CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, 623 MaybeAlign SrcAlign, uint64_t Size, 624 bool isVolatile = false, MDNode *TBAATag = nullptr, 625 MDNode *TBAAStructTag = nullptr, 626 MDNode *ScopeTag = nullptr, 627 MDNode *NoAliasTag = nullptr) { 628 return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size), 629 isVolatile, TBAATag, TBAAStructTag, ScopeTag, 630 NoAliasTag); 631 } 632 633 CallInst *CreateMemTransferInst( 634 Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, 635 MaybeAlign SrcAlign, Value *Size, bool isVolatile = false, 636 MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr, 637 MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr); 638 639 CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, 640 MaybeAlign SrcAlign, Value *Size, 641 bool isVolatile = false, MDNode *TBAATag = nullptr, 642 MDNode *TBAAStructTag = nullptr, 643 MDNode *ScopeTag = nullptr, 644 MDNode *NoAliasTag = nullptr) { 645 return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src, 646 SrcAlign, Size, isVolatile, TBAATag, 647 TBAAStructTag, ScopeTag, NoAliasTag); 648 } 649 650 CallInst *CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src, 651 MaybeAlign SrcAlign, Value *Size); 652 653 /// Create and insert an element unordered-atomic memcpy between the 654 /// specified pointers. 655 /// 656 /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively. 657 /// 658 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is 659 /// specified, it will be added to the instruction. Likewise with alias.scope 660 /// and noalias tags. 661 CallInst *CreateElementUnorderedAtomicMemCpy( 662 Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, 663 uint32_t ElementSize, MDNode *TBAATag = nullptr, 664 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, 665 MDNode *NoAliasTag = nullptr); 666 667 CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, 668 MaybeAlign SrcAlign, uint64_t Size, 669 bool isVolatile = false, MDNode *TBAATag = nullptr, 670 MDNode *ScopeTag = nullptr, 671 MDNode *NoAliasTag = nullptr) { 672 return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size), 673 isVolatile, TBAATag, ScopeTag, NoAliasTag); 674 } 675 676 CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, 677 MaybeAlign SrcAlign, Value *Size, 678 bool isVolatile = false, MDNode *TBAATag = nullptr, 679 MDNode *ScopeTag = nullptr, 680 MDNode *NoAliasTag = nullptr); 681 682 /// \brief Create and insert an element unordered-atomic memmove between the 683 /// specified pointers. 684 /// 685 /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, 686 /// respectively. 687 /// 688 /// If the pointers aren't i8*, they will be converted. If a TBAA tag is 689 /// specified, it will be added to the instruction. Likewise with alias.scope 690 /// and noalias tags. 691 CallInst *CreateElementUnorderedAtomicMemMove( 692 Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, 693 uint32_t ElementSize, MDNode *TBAATag = nullptr, 694 MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, 695 MDNode *NoAliasTag = nullptr); 696 697 /// Create a vector fadd reduction intrinsic of the source vector. 698 /// The first parameter is a scalar accumulator value for ordered reductions. 699 CallInst *CreateFAddReduce(Value *Acc, Value *Src); 700 701 /// Create a vector fmul reduction intrinsic of the source vector. 702 /// The first parameter is a scalar accumulator value for ordered reductions. 703 CallInst *CreateFMulReduce(Value *Acc, Value *Src); 704 705 /// Create a vector int add reduction intrinsic of the source vector. 706 CallInst *CreateAddReduce(Value *Src); 707 708 /// Create a vector int mul reduction intrinsic of the source vector. 709 CallInst *CreateMulReduce(Value *Src); 710 711 /// Create a vector int AND reduction intrinsic of the source vector. 712 CallInst *CreateAndReduce(Value *Src); 713 714 /// Create a vector int OR reduction intrinsic of the source vector. 715 CallInst *CreateOrReduce(Value *Src); 716 717 /// Create a vector int XOR reduction intrinsic of the source vector. 718 CallInst *CreateXorReduce(Value *Src); 719 720 /// Create a vector integer max reduction intrinsic of the source 721 /// vector. 722 CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false); 723 724 /// Create a vector integer min reduction intrinsic of the source 725 /// vector. 726 CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false); 727 728 /// Create a vector float max reduction intrinsic of the source 729 /// vector. 730 CallInst *CreateFPMaxReduce(Value *Src); 731 732 /// Create a vector float min reduction intrinsic of the source 733 /// vector. 734 CallInst *CreateFPMinReduce(Value *Src); 735 736 /// Create a lifetime.start intrinsic. 737 /// 738 /// If the pointer isn't i8* it will be converted. 739 CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr); 740 741 /// Create a lifetime.end intrinsic. 742 /// 743 /// If the pointer isn't i8* it will be converted. 744 CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr); 745 746 /// Create a call to invariant.start intrinsic. 747 /// 748 /// If the pointer isn't i8* it will be converted. 749 CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr); 750 751 /// Create a call to Masked Load intrinsic 752 CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask, 753 Value *PassThru = nullptr, const Twine &Name = ""); 754 755 /// Create a call to Masked Store intrinsic 756 CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment, 757 Value *Mask); 758 759 /// Create a call to Masked Gather intrinsic 760 CallInst *CreateMaskedGather(Value *Ptrs, Align Alignment, 761 Value *Mask = nullptr, Value *PassThru = nullptr, 762 const Twine &Name = ""); 763 764 /// Create a call to Masked Scatter intrinsic 765 CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment, 766 Value *Mask = nullptr); 767 768 /// Create an assume intrinsic call that allows the optimizer to 769 /// assume that the provided condition will be true. 770 /// 771 /// The optional argument \p OpBundles specifies operand bundles that are 772 /// added to the call instruction. 773 CallInst *CreateAssumption(Value *Cond, 774 ArrayRef<OperandBundleDef> OpBundles = llvm::None); 775 776 /// Create a llvm.experimental.noalias.scope.decl intrinsic call. 777 Instruction *CreateNoAliasScopeDeclaration(Value *Scope); CreateNoAliasScopeDeclaration(MDNode * ScopeTag)778 Instruction *CreateNoAliasScopeDeclaration(MDNode *ScopeTag) { 779 return CreateNoAliasScopeDeclaration( 780 MetadataAsValue::get(Context, ScopeTag)); 781 } 782 783 /// Create a call to the experimental.gc.statepoint intrinsic to 784 /// start a new statepoint sequence. 785 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, 786 Value *ActualCallee, 787 ArrayRef<Value *> CallArgs, 788 Optional<ArrayRef<Value *>> DeoptArgs, 789 ArrayRef<Value *> GCArgs, 790 const Twine &Name = ""); 791 792 /// Create a call to the experimental.gc.statepoint intrinsic to 793 /// start a new statepoint sequence. 794 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, 795 Value *ActualCallee, uint32_t Flags, 796 ArrayRef<Value *> CallArgs, 797 Optional<ArrayRef<Use>> TransitionArgs, 798 Optional<ArrayRef<Use>> DeoptArgs, 799 ArrayRef<Value *> GCArgs, 800 const Twine &Name = ""); 801 802 /// Conveninence function for the common case when CallArgs are filled 803 /// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be 804 /// .get()'ed to get the Value pointer. 805 CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes, 806 Value *ActualCallee, ArrayRef<Use> CallArgs, 807 Optional<ArrayRef<Value *>> DeoptArgs, 808 ArrayRef<Value *> GCArgs, 809 const Twine &Name = ""); 810 811 /// Create an invoke to the experimental.gc.statepoint intrinsic to 812 /// start a new statepoint sequence. 813 InvokeInst * 814 CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes, 815 Value *ActualInvokee, BasicBlock *NormalDest, 816 BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs, 817 Optional<ArrayRef<Value *>> DeoptArgs, 818 ArrayRef<Value *> GCArgs, const Twine &Name = ""); 819 820 /// Create an invoke to the experimental.gc.statepoint intrinsic to 821 /// start a new statepoint sequence. 822 InvokeInst *CreateGCStatepointInvoke( 823 uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee, 824 BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags, 825 ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs, 826 Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs, 827 const Twine &Name = ""); 828 829 // Convenience function for the common case when CallArgs are filled in using 830 // makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to 831 // get the Value *. 832 InvokeInst * 833 CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes, 834 Value *ActualInvokee, BasicBlock *NormalDest, 835 BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs, 836 Optional<ArrayRef<Value *>> DeoptArgs, 837 ArrayRef<Value *> GCArgs, const Twine &Name = ""); 838 839 /// Create a call to the experimental.gc.result intrinsic to extract 840 /// the result from a call wrapped in a statepoint. 841 CallInst *CreateGCResult(Instruction *Statepoint, 842 Type *ResultType, 843 const Twine &Name = ""); 844 845 /// Create a call to the experimental.gc.relocate intrinsics to 846 /// project the relocated value of one pointer from the statepoint. 847 CallInst *CreateGCRelocate(Instruction *Statepoint, 848 int BaseOffset, 849 int DerivedOffset, 850 Type *ResultType, 851 const Twine &Name = ""); 852 853 /// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale 854 /// will be the same type as that of \p Scaling. 855 Value *CreateVScale(Constant *Scaling, const Twine &Name = ""); 856 857 /// Creates a vector of type \p DstType with the linear sequence <0, 1, ...> 858 Value *CreateStepVector(Type *DstType, const Twine &Name = ""); 859 860 /// Create a call to intrinsic \p ID with 1 operand which is mangled on its 861 /// type. 862 CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V, 863 Instruction *FMFSource = nullptr, 864 const Twine &Name = ""); 865 866 /// Create a call to intrinsic \p ID with 2 operands which is mangled on the 867 /// first type. 868 CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS, 869 Instruction *FMFSource = nullptr, 870 const Twine &Name = ""); 871 872 /// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If 873 /// \p FMFSource is provided, copy fast-math-flags from that instruction to 874 /// the intrinsic. 875 CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types, 876 ArrayRef<Value *> Args, 877 Instruction *FMFSource = nullptr, 878 const Twine &Name = ""); 879 880 /// Create call to the minnum intrinsic. 881 CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") { 882 return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name); 883 } 884 885 /// Create call to the maxnum intrinsic. 886 CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") { 887 return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name); 888 } 889 890 /// Create call to the minimum intrinsic. 891 CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") { 892 return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name); 893 } 894 895 /// Create call to the maximum intrinsic. 896 CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") { 897 return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name); 898 } 899 900 /// Create a call to the experimental.vector.extract intrinsic. 901 CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx, 902 const Twine &Name = "") { 903 return CreateIntrinsic(Intrinsic::experimental_vector_extract, 904 {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr, 905 Name); 906 } 907 908 /// Create a call to the experimental.vector.insert intrinsic. 909 CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec, 910 Value *Idx, const Twine &Name = "") { 911 return CreateIntrinsic(Intrinsic::experimental_vector_insert, 912 {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx}, 913 nullptr, Name); 914 } 915 916 private: 917 /// Create a call to a masked intrinsic with given Id. 918 CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops, 919 ArrayRef<Type *> OverloadedTypes, 920 const Twine &Name = ""); 921 922 Value *getCastedInt8PtrValue(Value *Ptr); 923 924 //===--------------------------------------------------------------------===// 925 // Instruction creation methods: Terminators 926 //===--------------------------------------------------------------------===// 927 928 private: 929 /// Helper to add branch weight and unpredictable metadata onto an 930 /// instruction. 931 /// \returns The annotated instruction. 932 template <typename InstTy> addBranchMetadata(InstTy * I,MDNode * Weights,MDNode * Unpredictable)933 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) { 934 if (Weights) 935 I->setMetadata(LLVMContext::MD_prof, Weights); 936 if (Unpredictable) 937 I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable); 938 return I; 939 } 940 941 public: 942 /// Create a 'ret void' instruction. CreateRetVoid()943 ReturnInst *CreateRetVoid() { 944 return Insert(ReturnInst::Create(Context)); 945 } 946 947 /// Create a 'ret <val>' instruction. CreateRet(Value * V)948 ReturnInst *CreateRet(Value *V) { 949 return Insert(ReturnInst::Create(Context, V)); 950 } 951 952 /// Create a sequence of N insertvalue instructions, 953 /// with one Value from the retVals array each, that build a aggregate 954 /// return value one value at a time, and a ret instruction to return 955 /// the resulting aggregate value. 956 /// 957 /// This is a convenience function for code that uses aggregate return values 958 /// as a vehicle for having multiple return values. CreateAggregateRet(Value * const * retVals,unsigned N)959 ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) { 960 Value *V = UndefValue::get(getCurrentFunctionReturnType()); 961 for (unsigned i = 0; i != N; ++i) 962 V = CreateInsertValue(V, retVals[i], i, "mrv"); 963 return Insert(ReturnInst::Create(Context, V)); 964 } 965 966 /// Create an unconditional 'br label X' instruction. CreateBr(BasicBlock * Dest)967 BranchInst *CreateBr(BasicBlock *Dest) { 968 return Insert(BranchInst::Create(Dest)); 969 } 970 971 /// Create a conditional 'br Cond, TrueDest, FalseDest' 972 /// instruction. 973 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, 974 MDNode *BranchWeights = nullptr, 975 MDNode *Unpredictable = nullptr) { 976 return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond), 977 BranchWeights, Unpredictable)); 978 } 979 980 /// Create a conditional 'br Cond, TrueDest, FalseDest' 981 /// instruction. Copy branch meta data if available. CreateCondBr(Value * Cond,BasicBlock * True,BasicBlock * False,Instruction * MDSrc)982 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, 983 Instruction *MDSrc) { 984 BranchInst *Br = BranchInst::Create(True, False, Cond); 985 if (MDSrc) { 986 unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable, 987 LLVMContext::MD_make_implicit, LLVMContext::MD_dbg}; 988 Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4)); 989 } 990 return Insert(Br); 991 } 992 993 /// Create a switch instruction with the specified value, default dest, 994 /// and with a hint for the number of cases that will be added (for efficient 995 /// allocation). 996 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10, 997 MDNode *BranchWeights = nullptr, 998 MDNode *Unpredictable = nullptr) { 999 return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases), 1000 BranchWeights, Unpredictable)); 1001 } 1002 1003 /// Create an indirect branch instruction with the specified address 1004 /// operand, with an optional hint for the number of destinations that will be 1005 /// added (for efficient allocation). 1006 IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) { 1007 return Insert(IndirectBrInst::Create(Addr, NumDests)); 1008 } 1009 1010 /// Create an invoke instruction. 1011 InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee, 1012 BasicBlock *NormalDest, BasicBlock *UnwindDest, 1013 ArrayRef<Value *> Args, 1014 ArrayRef<OperandBundleDef> OpBundles, 1015 const Twine &Name = "") { 1016 InvokeInst *II = 1017 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles); 1018 if (IsFPConstrained) 1019 setConstrainedFPCallAttr(II); 1020 return Insert(II, Name); 1021 } 1022 InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee, 1023 BasicBlock *NormalDest, BasicBlock *UnwindDest, 1024 ArrayRef<Value *> Args = None, 1025 const Twine &Name = "") { 1026 InvokeInst *II = 1027 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args); 1028 if (IsFPConstrained) 1029 setConstrainedFPCallAttr(II); 1030 return Insert(II, Name); 1031 } 1032 1033 InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest, 1034 BasicBlock *UnwindDest, ArrayRef<Value *> Args, 1035 ArrayRef<OperandBundleDef> OpBundles, 1036 const Twine &Name = "") { 1037 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(), 1038 NormalDest, UnwindDest, Args, OpBundles, Name); 1039 } 1040 1041 InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest, 1042 BasicBlock *UnwindDest, 1043 ArrayRef<Value *> Args = None, 1044 const Twine &Name = "") { 1045 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(), 1046 NormalDest, UnwindDest, Args, Name); 1047 } 1048 1049 /// \brief Create a callbr instruction. 1050 CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee, 1051 BasicBlock *DefaultDest, 1052 ArrayRef<BasicBlock *> IndirectDests, 1053 ArrayRef<Value *> Args = None, 1054 const Twine &Name = "") { 1055 return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, 1056 Args), Name); 1057 } 1058 CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee, 1059 BasicBlock *DefaultDest, 1060 ArrayRef<BasicBlock *> IndirectDests, 1061 ArrayRef<Value *> Args, 1062 ArrayRef<OperandBundleDef> OpBundles, 1063 const Twine &Name = "") { 1064 return Insert( 1065 CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args, 1066 OpBundles), Name); 1067 } 1068 1069 CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest, 1070 ArrayRef<BasicBlock *> IndirectDests, 1071 ArrayRef<Value *> Args = None, 1072 const Twine &Name = "") { 1073 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(), 1074 DefaultDest, IndirectDests, Args, Name); 1075 } 1076 CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest, 1077 ArrayRef<BasicBlock *> IndirectDests, 1078 ArrayRef<Value *> Args, 1079 ArrayRef<OperandBundleDef> OpBundles, 1080 const Twine &Name = "") { 1081 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(), 1082 DefaultDest, IndirectDests, Args, Name); 1083 } 1084 CreateResume(Value * Exn)1085 ResumeInst *CreateResume(Value *Exn) { 1086 return Insert(ResumeInst::Create(Exn)); 1087 } 1088 1089 CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad, 1090 BasicBlock *UnwindBB = nullptr) { 1091 return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB)); 1092 } 1093 1094 CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB, 1095 unsigned NumHandlers, 1096 const Twine &Name = "") { 1097 return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers), 1098 Name); 1099 } 1100 1101 CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args, 1102 const Twine &Name = "") { 1103 return Insert(CatchPadInst::Create(ParentPad, Args), Name); 1104 } 1105 1106 CleanupPadInst *CreateCleanupPad(Value *ParentPad, 1107 ArrayRef<Value *> Args = None, 1108 const Twine &Name = "") { 1109 return Insert(CleanupPadInst::Create(ParentPad, Args), Name); 1110 } 1111 CreateCatchRet(CatchPadInst * CatchPad,BasicBlock * BB)1112 CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) { 1113 return Insert(CatchReturnInst::Create(CatchPad, BB)); 1114 } 1115 CreateUnreachable()1116 UnreachableInst *CreateUnreachable() { 1117 return Insert(new UnreachableInst(Context)); 1118 } 1119 1120 //===--------------------------------------------------------------------===// 1121 // Instruction creation methods: Binary Operators 1122 //===--------------------------------------------------------------------===// 1123 private: CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,Value * LHS,Value * RHS,const Twine & Name,bool HasNUW,bool HasNSW)1124 BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc, 1125 Value *LHS, Value *RHS, 1126 const Twine &Name, 1127 bool HasNUW, bool HasNSW) { 1128 BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name); 1129 if (HasNUW) BO->setHasNoUnsignedWrap(); 1130 if (HasNSW) BO->setHasNoSignedWrap(); 1131 return BO; 1132 } 1133 setFPAttrs(Instruction * I,MDNode * FPMD,FastMathFlags FMF)1134 Instruction *setFPAttrs(Instruction *I, MDNode *FPMD, 1135 FastMathFlags FMF) const { 1136 if (!FPMD) 1137 FPMD = DefaultFPMathTag; 1138 if (FPMD) 1139 I->setMetadata(LLVMContext::MD_fpmath, FPMD); 1140 I->setFastMathFlags(FMF); 1141 return I; 1142 } 1143 foldConstant(Instruction::BinaryOps Opc,Value * L,Value * R,const Twine & Name)1144 Value *foldConstant(Instruction::BinaryOps Opc, Value *L, 1145 Value *R, const Twine &Name) const { 1146 auto *LC = dyn_cast<Constant>(L); 1147 auto *RC = dyn_cast<Constant>(R); 1148 return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr; 1149 } 1150 getConstrainedFPRounding(Optional<RoundingMode> Rounding)1151 Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) { 1152 RoundingMode UseRounding = DefaultConstrainedRounding; 1153 1154 if (Rounding.hasValue()) 1155 UseRounding = Rounding.getValue(); 1156 1157 Optional<StringRef> RoundingStr = RoundingModeToStr(UseRounding); 1158 assert(RoundingStr.hasValue() && "Garbage strict rounding mode!"); 1159 auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue()); 1160 1161 return MetadataAsValue::get(Context, RoundingMDS); 1162 } 1163 getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except)1164 Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) { 1165 fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept; 1166 1167 if (Except.hasValue()) 1168 UseExcept = Except.getValue(); 1169 1170 Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(UseExcept); 1171 assert(ExceptStr.hasValue() && "Garbage strict exception behavior!"); 1172 auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue()); 1173 1174 return MetadataAsValue::get(Context, ExceptMDS); 1175 } 1176 getConstrainedFPPredicate(CmpInst::Predicate Predicate)1177 Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) { 1178 assert(CmpInst::isFPPredicate(Predicate) && 1179 Predicate != CmpInst::FCMP_FALSE && 1180 Predicate != CmpInst::FCMP_TRUE && 1181 "Invalid constrained FP comparison predicate!"); 1182 1183 StringRef PredicateStr = CmpInst::getPredicateName(Predicate); 1184 auto *PredicateMDS = MDString::get(Context, PredicateStr); 1185 1186 return MetadataAsValue::get(Context, PredicateMDS); 1187 } 1188 1189 public: 1190 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "", 1191 bool HasNUW = false, bool HasNSW = false) { 1192 if (auto *LC = dyn_cast<Constant>(LHS)) 1193 if (auto *RC = dyn_cast<Constant>(RHS)) 1194 return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name); 1195 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name, 1196 HasNUW, HasNSW); 1197 } 1198 1199 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 1200 return CreateAdd(LHS, RHS, Name, false, true); 1201 } 1202 1203 Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") { 1204 return CreateAdd(LHS, RHS, Name, true, false); 1205 } 1206 1207 Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "", 1208 bool HasNUW = false, bool HasNSW = false) { 1209 if (auto *LC = dyn_cast<Constant>(LHS)) 1210 if (auto *RC = dyn_cast<Constant>(RHS)) 1211 return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name); 1212 return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name, 1213 HasNUW, HasNSW); 1214 } 1215 1216 Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") { 1217 return CreateSub(LHS, RHS, Name, false, true); 1218 } 1219 1220 Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") { 1221 return CreateSub(LHS, RHS, Name, true, false); 1222 } 1223 1224 Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "", 1225 bool HasNUW = false, bool HasNSW = false) { 1226 if (auto *LC = dyn_cast<Constant>(LHS)) 1227 if (auto *RC = dyn_cast<Constant>(RHS)) 1228 return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name); 1229 return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name, 1230 HasNUW, HasNSW); 1231 } 1232 1233 Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") { 1234 return CreateMul(LHS, RHS, Name, false, true); 1235 } 1236 1237 Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") { 1238 return CreateMul(LHS, RHS, Name, true, false); 1239 } 1240 1241 Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "", 1242 bool isExact = false) { 1243 if (auto *LC = dyn_cast<Constant>(LHS)) 1244 if (auto *RC = dyn_cast<Constant>(RHS)) 1245 return Insert(Folder.CreateUDiv(LC, RC, isExact), Name); 1246 if (!isExact) 1247 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name); 1248 return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name); 1249 } 1250 1251 Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 1252 return CreateUDiv(LHS, RHS, Name, true); 1253 } 1254 1255 Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "", 1256 bool isExact = false) { 1257 if (auto *LC = dyn_cast<Constant>(LHS)) 1258 if (auto *RC = dyn_cast<Constant>(RHS)) 1259 return Insert(Folder.CreateSDiv(LC, RC, isExact), Name); 1260 if (!isExact) 1261 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name); 1262 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name); 1263 } 1264 1265 Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") { 1266 return CreateSDiv(LHS, RHS, Name, true); 1267 } 1268 1269 Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") { 1270 if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) return V; 1271 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name); 1272 } 1273 1274 Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") { 1275 if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) return V; 1276 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name); 1277 } 1278 1279 Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "", 1280 bool HasNUW = false, bool HasNSW = false) { 1281 if (auto *LC = dyn_cast<Constant>(LHS)) 1282 if (auto *RC = dyn_cast<Constant>(RHS)) 1283 return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name); 1284 return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name, 1285 HasNUW, HasNSW); 1286 } 1287 1288 Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "", 1289 bool HasNUW = false, bool HasNSW = false) { 1290 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name, 1291 HasNUW, HasNSW); 1292 } 1293 1294 Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "", 1295 bool HasNUW = false, bool HasNSW = false) { 1296 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name, 1297 HasNUW, HasNSW); 1298 } 1299 1300 Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "", 1301 bool isExact = false) { 1302 if (auto *LC = dyn_cast<Constant>(LHS)) 1303 if (auto *RC = dyn_cast<Constant>(RHS)) 1304 return Insert(Folder.CreateLShr(LC, RC, isExact), Name); 1305 if (!isExact) 1306 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name); 1307 return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name); 1308 } 1309 1310 Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "", 1311 bool isExact = false) { 1312 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 1313 } 1314 1315 Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "", 1316 bool isExact = false) { 1317 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 1318 } 1319 1320 Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "", 1321 bool isExact = false) { 1322 if (auto *LC = dyn_cast<Constant>(LHS)) 1323 if (auto *RC = dyn_cast<Constant>(RHS)) 1324 return Insert(Folder.CreateAShr(LC, RC, isExact), Name); 1325 if (!isExact) 1326 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name); 1327 return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name); 1328 } 1329 1330 Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "", 1331 bool isExact = false) { 1332 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 1333 } 1334 1335 Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "", 1336 bool isExact = false) { 1337 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact); 1338 } 1339 1340 Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") { 1341 if (auto *RC = dyn_cast<Constant>(RHS)) { 1342 if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne()) 1343 return LHS; // LHS & -1 -> LHS 1344 if (auto *LC = dyn_cast<Constant>(LHS)) 1345 return Insert(Folder.CreateAnd(LC, RC), Name); 1346 } 1347 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name); 1348 } 1349 1350 Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") { 1351 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 1352 } 1353 1354 Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") { 1355 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 1356 } 1357 CreateAnd(ArrayRef<Value * > Ops)1358 Value *CreateAnd(ArrayRef<Value*> Ops) { 1359 assert(!Ops.empty()); 1360 Value *Accum = Ops[0]; 1361 for (unsigned i = 1; i < Ops.size(); i++) 1362 Accum = CreateAnd(Accum, Ops[i]); 1363 return Accum; 1364 } 1365 1366 Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") { 1367 if (auto *RC = dyn_cast<Constant>(RHS)) { 1368 if (RC->isNullValue()) 1369 return LHS; // LHS | 0 -> LHS 1370 if (auto *LC = dyn_cast<Constant>(LHS)) 1371 return Insert(Folder.CreateOr(LC, RC), Name); 1372 } 1373 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name); 1374 } 1375 1376 Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") { 1377 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 1378 } 1379 1380 Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") { 1381 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 1382 } 1383 CreateOr(ArrayRef<Value * > Ops)1384 Value *CreateOr(ArrayRef<Value*> Ops) { 1385 assert(!Ops.empty()); 1386 Value *Accum = Ops[0]; 1387 for (unsigned i = 1; i < Ops.size(); i++) 1388 Accum = CreateOr(Accum, Ops[i]); 1389 return Accum; 1390 } 1391 1392 Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") { 1393 if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) return V; 1394 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name); 1395 } 1396 1397 Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") { 1398 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 1399 } 1400 1401 Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") { 1402 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name); 1403 } 1404 1405 Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "", 1406 MDNode *FPMD = nullptr) { 1407 if (IsFPConstrained) 1408 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd, 1409 L, R, nullptr, Name, FPMD); 1410 1411 if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V; 1412 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF); 1413 return Insert(I, Name); 1414 } 1415 1416 /// Copy fast-math-flags from an instruction rather than using the builder's 1417 /// default FMF. 1418 Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource, 1419 const Twine &Name = "") { 1420 if (IsFPConstrained) 1421 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd, 1422 L, R, FMFSource, Name); 1423 1424 if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V; 1425 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr, 1426 FMFSource->getFastMathFlags()); 1427 return Insert(I, Name); 1428 } 1429 1430 Value *CreateFSub(Value *L, Value *R, const Twine &Name = "", 1431 MDNode *FPMD = nullptr) { 1432 if (IsFPConstrained) 1433 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub, 1434 L, R, nullptr, Name, FPMD); 1435 1436 if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V; 1437 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF); 1438 return Insert(I, Name); 1439 } 1440 1441 /// Copy fast-math-flags from an instruction rather than using the builder's 1442 /// default FMF. 1443 Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource, 1444 const Twine &Name = "") { 1445 if (IsFPConstrained) 1446 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub, 1447 L, R, FMFSource, Name); 1448 1449 if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V; 1450 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr, 1451 FMFSource->getFastMathFlags()); 1452 return Insert(I, Name); 1453 } 1454 1455 Value *CreateFMul(Value *L, Value *R, const Twine &Name = "", 1456 MDNode *FPMD = nullptr) { 1457 if (IsFPConstrained) 1458 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul, 1459 L, R, nullptr, Name, FPMD); 1460 1461 if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V; 1462 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF); 1463 return Insert(I, Name); 1464 } 1465 1466 /// Copy fast-math-flags from an instruction rather than using the builder's 1467 /// default FMF. 1468 Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource, 1469 const Twine &Name = "") { 1470 if (IsFPConstrained) 1471 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul, 1472 L, R, FMFSource, Name); 1473 1474 if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V; 1475 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr, 1476 FMFSource->getFastMathFlags()); 1477 return Insert(I, Name); 1478 } 1479 1480 Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "", 1481 MDNode *FPMD = nullptr) { 1482 if (IsFPConstrained) 1483 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv, 1484 L, R, nullptr, Name, FPMD); 1485 1486 if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V; 1487 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF); 1488 return Insert(I, Name); 1489 } 1490 1491 /// Copy fast-math-flags from an instruction rather than using the builder's 1492 /// default FMF. 1493 Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource, 1494 const Twine &Name = "") { 1495 if (IsFPConstrained) 1496 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv, 1497 L, R, FMFSource, Name); 1498 1499 if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V; 1500 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr, 1501 FMFSource->getFastMathFlags()); 1502 return Insert(I, Name); 1503 } 1504 1505 Value *CreateFRem(Value *L, Value *R, const Twine &Name = "", 1506 MDNode *FPMD = nullptr) { 1507 if (IsFPConstrained) 1508 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem, 1509 L, R, nullptr, Name, FPMD); 1510 1511 if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V; 1512 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF); 1513 return Insert(I, Name); 1514 } 1515 1516 /// Copy fast-math-flags from an instruction rather than using the builder's 1517 /// default FMF. 1518 Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource, 1519 const Twine &Name = "") { 1520 if (IsFPConstrained) 1521 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem, 1522 L, R, FMFSource, Name); 1523 1524 if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V; 1525 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr, 1526 FMFSource->getFastMathFlags()); 1527 return Insert(I, Name); 1528 } 1529 1530 Value *CreateBinOp(Instruction::BinaryOps Opc, 1531 Value *LHS, Value *RHS, const Twine &Name = "", 1532 MDNode *FPMathTag = nullptr) { 1533 if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V; 1534 Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS); 1535 if (isa<FPMathOperator>(BinOp)) 1536 setFPAttrs(BinOp, FPMathTag, FMF); 1537 return Insert(BinOp, Name); 1538 } 1539 1540 Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") { 1541 assert(Cond2->getType()->isIntOrIntVectorTy(1)); 1542 return CreateSelect(Cond1, Cond2, 1543 ConstantInt::getNullValue(Cond2->getType()), Name); 1544 } 1545 1546 Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") { 1547 assert(Cond2->getType()->isIntOrIntVectorTy(1)); 1548 return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()), 1549 Cond2, Name); 1550 } 1551 1552 CallInst *CreateConstrainedFPBinOp( 1553 Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr, 1554 const Twine &Name = "", MDNode *FPMathTag = nullptr, 1555 Optional<RoundingMode> Rounding = None, 1556 Optional<fp::ExceptionBehavior> Except = None); 1557 1558 Value *CreateNeg(Value *V, const Twine &Name = "", 1559 bool HasNUW = false, bool HasNSW = false) { 1560 if (auto *VC = dyn_cast<Constant>(V)) 1561 return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name); 1562 BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name); 1563 if (HasNUW) BO->setHasNoUnsignedWrap(); 1564 if (HasNSW) BO->setHasNoSignedWrap(); 1565 return BO; 1566 } 1567 1568 Value *CreateNSWNeg(Value *V, const Twine &Name = "") { 1569 return CreateNeg(V, Name, false, true); 1570 } 1571 1572 Value *CreateNUWNeg(Value *V, const Twine &Name = "") { 1573 return CreateNeg(V, Name, true, false); 1574 } 1575 1576 Value *CreateFNeg(Value *V, const Twine &Name = "", 1577 MDNode *FPMathTag = nullptr) { 1578 if (auto *VC = dyn_cast<Constant>(V)) 1579 return Insert(Folder.CreateFNeg(VC), Name); 1580 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF), 1581 Name); 1582 } 1583 1584 /// Copy fast-math-flags from an instruction rather than using the builder's 1585 /// default FMF. 1586 Value *CreateFNegFMF(Value *V, Instruction *FMFSource, 1587 const Twine &Name = "") { 1588 if (auto *VC = dyn_cast<Constant>(V)) 1589 return Insert(Folder.CreateFNeg(VC), Name); 1590 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr, 1591 FMFSource->getFastMathFlags()), 1592 Name); 1593 } 1594 1595 Value *CreateNot(Value *V, const Twine &Name = "") { 1596 if (auto *VC = dyn_cast<Constant>(V)) 1597 return Insert(Folder.CreateNot(VC), Name); 1598 return Insert(BinaryOperator::CreateNot(V), Name); 1599 } 1600 1601 Value *CreateUnOp(Instruction::UnaryOps Opc, 1602 Value *V, const Twine &Name = "", 1603 MDNode *FPMathTag = nullptr) { 1604 if (auto *VC = dyn_cast<Constant>(V)) 1605 return Insert(Folder.CreateUnOp(Opc, VC), Name); 1606 Instruction *UnOp = UnaryOperator::Create(Opc, V); 1607 if (isa<FPMathOperator>(UnOp)) 1608 setFPAttrs(UnOp, FPMathTag, FMF); 1609 return Insert(UnOp, Name); 1610 } 1611 1612 /// Create either a UnaryOperator or BinaryOperator depending on \p Opc. 1613 /// Correct number of operands must be passed accordingly. 1614 Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops, 1615 const Twine &Name = "", MDNode *FPMathTag = nullptr); 1616 1617 //===--------------------------------------------------------------------===// 1618 // Instruction creation methods: Memory Instructions 1619 //===--------------------------------------------------------------------===// 1620 1621 AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace, 1622 Value *ArraySize = nullptr, const Twine &Name = "") { 1623 const DataLayout &DL = BB->getModule()->getDataLayout(); 1624 Align AllocaAlign = DL.getPrefTypeAlign(Ty); 1625 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name); 1626 } 1627 1628 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr, 1629 const Twine &Name = "") { 1630 const DataLayout &DL = BB->getModule()->getDataLayout(); 1631 Align AllocaAlign = DL.getPrefTypeAlign(Ty); 1632 unsigned AddrSpace = DL.getAllocaAddrSpace(); 1633 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name); 1634 } 1635 1636 /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of 1637 /// converting the string to 'bool' for the isVolatile parameter. CreateLoad(Type * Ty,Value * Ptr,const char * Name)1638 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) { 1639 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name); 1640 } 1641 1642 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") { 1643 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name); 1644 } 1645 1646 LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile, 1647 const Twine &Name = "") { 1648 return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name); 1649 } 1650 1651 // Deprecated [opaque pointer types] 1652 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr, 1653 const char *Name), 1654 "Use the version that explicitly specifies the " 1655 "loaded type instead") { 1656 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name); 1657 } 1658 1659 // Deprecated [opaque pointer types] 1660 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr, 1661 const Twine &Name = ""), 1662 "Use the version that explicitly specifies the " 1663 "loaded type instead") { 1664 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name); 1665 } 1666 1667 // Deprecated [opaque pointer types] 1668 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateLoad(Value *Ptr, 1669 bool isVolatile, 1670 const Twine &Name = ""), 1671 "Use the version that explicitly specifies the " 1672 "loaded type instead") { 1673 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile, 1674 Name); 1675 } 1676 1677 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) { 1678 return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile); 1679 } 1680 CreateAlignedLoad(Type * Ty,Value * Ptr,MaybeAlign Align,const char * Name)1681 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, 1682 const char *Name) { 1683 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name); 1684 } 1685 1686 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, 1687 const Twine &Name = "") { 1688 return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name); 1689 } 1690 1691 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, 1692 bool isVolatile, const Twine &Name = "") { 1693 if (!Align) { 1694 const DataLayout &DL = BB->getModule()->getDataLayout(); 1695 Align = DL.getABITypeAlign(Ty); 1696 } 1697 return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name); 1698 } 1699 1700 // Deprecated [opaque pointer types] 1701 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr, 1702 MaybeAlign Align, 1703 const char *Name), 1704 "Use the version that explicitly specifies the " 1705 "loaded type instead") { 1706 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr, 1707 Align, Name); 1708 } 1709 // Deprecated [opaque pointer types] 1710 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr, 1711 MaybeAlign Align, 1712 const Twine &Name = ""), 1713 "Use the version that explicitly specifies the " 1714 "loaded type instead") { 1715 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr, 1716 Align, Name); 1717 } 1718 // Deprecated [opaque pointer types] 1719 LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr, 1720 MaybeAlign Align, 1721 bool isVolatile, 1722 const Twine &Name = ""), 1723 "Use the version that explicitly specifies the " 1724 "loaded type instead") { 1725 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr, 1726 Align, isVolatile, Name); 1727 } 1728 1729 StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, 1730 bool isVolatile = false) { 1731 if (!Align) { 1732 const DataLayout &DL = BB->getModule()->getDataLayout(); 1733 Align = DL.getABITypeAlign(Val->getType()); 1734 } 1735 return Insert(new StoreInst(Val, Ptr, isVolatile, *Align)); 1736 } 1737 FenceInst *CreateFence(AtomicOrdering Ordering, 1738 SyncScope::ID SSID = SyncScope::System, 1739 const Twine &Name = "") { 1740 return Insert(new FenceInst(Context, Ordering, SSID), Name); 1741 } 1742 1743 AtomicCmpXchgInst * 1744 CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New, MaybeAlign Align, 1745 AtomicOrdering SuccessOrdering, 1746 AtomicOrdering FailureOrdering, 1747 SyncScope::ID SSID = SyncScope::System) { 1748 if (!Align) { 1749 const DataLayout &DL = BB->getModule()->getDataLayout(); 1750 Align = llvm::Align(DL.getTypeStoreSize(New->getType())); 1751 } 1752 1753 return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering, 1754 FailureOrdering, SSID)); 1755 } 1756 1757 AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, 1758 Value *Val, MaybeAlign Align, 1759 AtomicOrdering Ordering, 1760 SyncScope::ID SSID = SyncScope::System) { 1761 if (!Align) { 1762 const DataLayout &DL = BB->getModule()->getDataLayout(); 1763 Align = llvm::Align(DL.getTypeStoreSize(Val->getType())); 1764 } 1765 1766 return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID)); 1767 } 1768 1769 Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList, 1770 const Twine &Name = "") { 1771 return CreateGEP(nullptr, Ptr, IdxList, Name); 1772 } 1773 1774 Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList, 1775 const Twine &Name = "") { 1776 if (auto *PC = dyn_cast<Constant>(Ptr)) { 1777 // Every index must be constant. 1778 size_t i, e; 1779 for (i = 0, e = IdxList.size(); i != e; ++i) 1780 if (!isa<Constant>(IdxList[i])) 1781 break; 1782 if (i == e) 1783 return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name); 1784 } 1785 return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name); 1786 } 1787 1788 Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList, 1789 const Twine &Name = "") { 1790 return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name); 1791 } 1792 1793 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList, 1794 const Twine &Name = "") { 1795 if (auto *PC = dyn_cast<Constant>(Ptr)) { 1796 // Every index must be constant. 1797 size_t i, e; 1798 for (i = 0, e = IdxList.size(); i != e; ++i) 1799 if (!isa<Constant>(IdxList[i])) 1800 break; 1801 if (i == e) 1802 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList), 1803 Name); 1804 } 1805 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name); 1806 } 1807 1808 Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") { 1809 return CreateGEP(nullptr, Ptr, Idx, Name); 1810 } 1811 1812 Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") { 1813 if (auto *PC = dyn_cast<Constant>(Ptr)) 1814 if (auto *IC = dyn_cast<Constant>(Idx)) 1815 return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name); 1816 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name); 1817 } 1818 1819 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx, 1820 const Twine &Name = "") { 1821 if (auto *PC = dyn_cast<Constant>(Ptr)) 1822 if (auto *IC = dyn_cast<Constant>(Idx)) 1823 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name); 1824 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name); 1825 } 1826 1827 Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") { 1828 return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name); 1829 } 1830 1831 Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, 1832 const Twine &Name = "") { 1833 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0); 1834 1835 if (auto *PC = dyn_cast<Constant>(Ptr)) 1836 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name); 1837 1838 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name); 1839 } 1840 1841 Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, 1842 const Twine &Name = "") { 1843 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0); 1844 1845 if (auto *PC = dyn_cast<Constant>(Ptr)) 1846 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name); 1847 1848 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name); 1849 } 1850 1851 Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, 1852 const Twine &Name = "") { 1853 Value *Idxs[] = { 1854 ConstantInt::get(Type::getInt32Ty(Context), Idx0), 1855 ConstantInt::get(Type::getInt32Ty(Context), Idx1) 1856 }; 1857 1858 if (auto *PC = dyn_cast<Constant>(Ptr)) 1859 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name); 1860 1861 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name); 1862 } 1863 1864 Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, 1865 unsigned Idx1, const Twine &Name = "") { 1866 Value *Idxs[] = { 1867 ConstantInt::get(Type::getInt32Ty(Context), Idx0), 1868 ConstantInt::get(Type::getInt32Ty(Context), Idx1) 1869 }; 1870 1871 if (auto *PC = dyn_cast<Constant>(Ptr)) 1872 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name); 1873 1874 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name); 1875 } 1876 1877 Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, 1878 const Twine &Name = "") { 1879 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0); 1880 1881 if (auto *PC = dyn_cast<Constant>(Ptr)) 1882 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name); 1883 1884 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name); 1885 } 1886 1887 Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") { 1888 return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name); 1889 } 1890 1891 Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, 1892 const Twine &Name = "") { 1893 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0); 1894 1895 if (auto *PC = dyn_cast<Constant>(Ptr)) 1896 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name); 1897 1898 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name); 1899 } 1900 1901 Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0, 1902 const Twine &Name = "") { 1903 return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name); 1904 } 1905 1906 Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1, 1907 const Twine &Name = "") { 1908 Value *Idxs[] = { 1909 ConstantInt::get(Type::getInt64Ty(Context), Idx0), 1910 ConstantInt::get(Type::getInt64Ty(Context), Idx1) 1911 }; 1912 1913 if (auto *PC = dyn_cast<Constant>(Ptr)) 1914 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name); 1915 1916 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name); 1917 } 1918 1919 Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, 1920 const Twine &Name = "") { 1921 return CreateConstGEP2_64(nullptr, Ptr, Idx0, Idx1, Name); 1922 } 1923 1924 Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, 1925 uint64_t Idx1, const Twine &Name = "") { 1926 Value *Idxs[] = { 1927 ConstantInt::get(Type::getInt64Ty(Context), Idx0), 1928 ConstantInt::get(Type::getInt64Ty(Context), Idx1) 1929 }; 1930 1931 if (auto *PC = dyn_cast<Constant>(Ptr)) 1932 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name); 1933 1934 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name); 1935 } 1936 1937 Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, 1938 const Twine &Name = "") { 1939 return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name); 1940 } 1941 1942 Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx, 1943 const Twine &Name = "") { 1944 return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name); 1945 } 1946 1947 Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") { 1948 return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name); 1949 } 1950 1951 /// Same as CreateGlobalString, but return a pointer with "i8*" type 1952 /// instead of a pointer to array of i8. 1953 /// 1954 /// If no module is given via \p M, it is take from the insertion point basic 1955 /// block. 1956 Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "", 1957 unsigned AddressSpace = 0, 1958 Module *M = nullptr) { 1959 GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace, M); 1960 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0); 1961 Constant *Indices[] = {Zero, Zero}; 1962 return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV, 1963 Indices); 1964 } 1965 1966 //===--------------------------------------------------------------------===// 1967 // Instruction creation methods: Cast/Conversion Operators 1968 //===--------------------------------------------------------------------===// 1969 1970 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") { 1971 return CreateCast(Instruction::Trunc, V, DestTy, Name); 1972 } 1973 1974 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") { 1975 return CreateCast(Instruction::ZExt, V, DestTy, Name); 1976 } 1977 1978 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") { 1979 return CreateCast(Instruction::SExt, V, DestTy, Name); 1980 } 1981 1982 /// Create a ZExt or Trunc from the integer value V to DestTy. Return 1983 /// the value untouched if the type of V is already DestTy. 1984 Value *CreateZExtOrTrunc(Value *V, Type *DestTy, 1985 const Twine &Name = "") { 1986 assert(V->getType()->isIntOrIntVectorTy() && 1987 DestTy->isIntOrIntVectorTy() && 1988 "Can only zero extend/truncate integers!"); 1989 Type *VTy = V->getType(); 1990 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits()) 1991 return CreateZExt(V, DestTy, Name); 1992 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits()) 1993 return CreateTrunc(V, DestTy, Name); 1994 return V; 1995 } 1996 1997 /// Create a SExt or Trunc from the integer value V to DestTy. Return 1998 /// the value untouched if the type of V is already DestTy. 1999 Value *CreateSExtOrTrunc(Value *V, Type *DestTy, 2000 const Twine &Name = "") { 2001 assert(V->getType()->isIntOrIntVectorTy() && 2002 DestTy->isIntOrIntVectorTy() && 2003 "Can only sign extend/truncate integers!"); 2004 Type *VTy = V->getType(); 2005 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits()) 2006 return CreateSExt(V, DestTy, Name); 2007 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits()) 2008 return CreateTrunc(V, DestTy, Name); 2009 return V; 2010 } 2011 2012 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") { 2013 if (IsFPConstrained) 2014 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui, 2015 V, DestTy, nullptr, Name); 2016 return CreateCast(Instruction::FPToUI, V, DestTy, Name); 2017 } 2018 2019 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") { 2020 if (IsFPConstrained) 2021 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi, 2022 V, DestTy, nullptr, Name); 2023 return CreateCast(Instruction::FPToSI, V, DestTy, Name); 2024 } 2025 2026 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){ 2027 if (IsFPConstrained) 2028 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp, 2029 V, DestTy, nullptr, Name); 2030 return CreateCast(Instruction::UIToFP, V, DestTy, Name); 2031 } 2032 2033 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){ 2034 if (IsFPConstrained) 2035 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp, 2036 V, DestTy, nullptr, Name); 2037 return CreateCast(Instruction::SIToFP, V, DestTy, Name); 2038 } 2039 2040 Value *CreateFPTrunc(Value *V, Type *DestTy, 2041 const Twine &Name = "") { 2042 if (IsFPConstrained) 2043 return CreateConstrainedFPCast( 2044 Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr, 2045 Name); 2046 return CreateCast(Instruction::FPTrunc, V, DestTy, Name); 2047 } 2048 2049 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") { 2050 if (IsFPConstrained) 2051 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext, 2052 V, DestTy, nullptr, Name); 2053 return CreateCast(Instruction::FPExt, V, DestTy, Name); 2054 } 2055 2056 Value *CreatePtrToInt(Value *V, Type *DestTy, 2057 const Twine &Name = "") { 2058 return CreateCast(Instruction::PtrToInt, V, DestTy, Name); 2059 } 2060 2061 Value *CreateIntToPtr(Value *V, Type *DestTy, 2062 const Twine &Name = "") { 2063 return CreateCast(Instruction::IntToPtr, V, DestTy, Name); 2064 } 2065 2066 Value *CreateBitCast(Value *V, Type *DestTy, 2067 const Twine &Name = "") { 2068 return CreateCast(Instruction::BitCast, V, DestTy, Name); 2069 } 2070 2071 Value *CreateAddrSpaceCast(Value *V, Type *DestTy, 2072 const Twine &Name = "") { 2073 return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name); 2074 } 2075 2076 Value *CreateZExtOrBitCast(Value *V, Type *DestTy, 2077 const Twine &Name = "") { 2078 if (V->getType() == DestTy) 2079 return V; 2080 if (auto *VC = dyn_cast<Constant>(V)) 2081 return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name); 2082 return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name); 2083 } 2084 2085 Value *CreateSExtOrBitCast(Value *V, Type *DestTy, 2086 const Twine &Name = "") { 2087 if (V->getType() == DestTy) 2088 return V; 2089 if (auto *VC = dyn_cast<Constant>(V)) 2090 return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name); 2091 return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name); 2092 } 2093 2094 Value *CreateTruncOrBitCast(Value *V, Type *DestTy, 2095 const Twine &Name = "") { 2096 if (V->getType() == DestTy) 2097 return V; 2098 if (auto *VC = dyn_cast<Constant>(V)) 2099 return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name); 2100 return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name); 2101 } 2102 2103 Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, 2104 const Twine &Name = "") { 2105 if (V->getType() == DestTy) 2106 return V; 2107 if (auto *VC = dyn_cast<Constant>(V)) 2108 return Insert(Folder.CreateCast(Op, VC, DestTy), Name); 2109 return Insert(CastInst::Create(Op, V, DestTy), Name); 2110 } 2111 2112 Value *CreatePointerCast(Value *V, Type *DestTy, 2113 const Twine &Name = "") { 2114 if (V->getType() == DestTy) 2115 return V; 2116 if (auto *VC = dyn_cast<Constant>(V)) 2117 return Insert(Folder.CreatePointerCast(VC, DestTy), Name); 2118 return Insert(CastInst::CreatePointerCast(V, DestTy), Name); 2119 } 2120 2121 Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy, 2122 const Twine &Name = "") { 2123 if (V->getType() == DestTy) 2124 return V; 2125 2126 if (auto *VC = dyn_cast<Constant>(V)) { 2127 return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy), 2128 Name); 2129 } 2130 2131 return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy), 2132 Name); 2133 } 2134 2135 Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned, 2136 const Twine &Name = "") { 2137 if (V->getType() == DestTy) 2138 return V; 2139 if (auto *VC = dyn_cast<Constant>(V)) 2140 return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name); 2141 return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name); 2142 } 2143 2144 Value *CreateBitOrPointerCast(Value *V, Type *DestTy, 2145 const Twine &Name = "") { 2146 if (V->getType() == DestTy) 2147 return V; 2148 if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy()) 2149 return CreatePtrToInt(V, DestTy, Name); 2150 if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy()) 2151 return CreateIntToPtr(V, DestTy, Name); 2152 2153 return CreateBitCast(V, DestTy, Name); 2154 } 2155 2156 Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") { 2157 if (V->getType() == DestTy) 2158 return V; 2159 if (auto *VC = dyn_cast<Constant>(V)) 2160 return Insert(Folder.CreateFPCast(VC, DestTy), Name); 2161 return Insert(CastInst::CreateFPCast(V, DestTy), Name); 2162 } 2163 2164 CallInst *CreateConstrainedFPCast( 2165 Intrinsic::ID ID, Value *V, Type *DestTy, 2166 Instruction *FMFSource = nullptr, const Twine &Name = "", 2167 MDNode *FPMathTag = nullptr, 2168 Optional<RoundingMode> Rounding = None, 2169 Optional<fp::ExceptionBehavior> Except = None); 2170 2171 // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a 2172 // compile time error, instead of converting the string to bool for the 2173 // isSigned parameter. 2174 Value *CreateIntCast(Value *, Type *, const char *) = delete; 2175 2176 //===--------------------------------------------------------------------===// 2177 // Instruction creation methods: Compare Instructions 2178 //===--------------------------------------------------------------------===// 2179 2180 Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") { 2181 return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name); 2182 } 2183 2184 Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") { 2185 return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name); 2186 } 2187 2188 Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") { 2189 return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name); 2190 } 2191 2192 Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") { 2193 return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name); 2194 } 2195 2196 Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") { 2197 return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name); 2198 } 2199 2200 Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") { 2201 return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name); 2202 } 2203 2204 Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") { 2205 return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name); 2206 } 2207 2208 Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") { 2209 return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name); 2210 } 2211 2212 Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") { 2213 return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name); 2214 } 2215 2216 Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") { 2217 return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name); 2218 } 2219 2220 Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "", 2221 MDNode *FPMathTag = nullptr) { 2222 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag); 2223 } 2224 2225 Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "", 2226 MDNode *FPMathTag = nullptr) { 2227 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag); 2228 } 2229 2230 Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "", 2231 MDNode *FPMathTag = nullptr) { 2232 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag); 2233 } 2234 2235 Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "", 2236 MDNode *FPMathTag = nullptr) { 2237 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag); 2238 } 2239 2240 Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "", 2241 MDNode *FPMathTag = nullptr) { 2242 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag); 2243 } 2244 2245 Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "", 2246 MDNode *FPMathTag = nullptr) { 2247 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag); 2248 } 2249 2250 Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "", 2251 MDNode *FPMathTag = nullptr) { 2252 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag); 2253 } 2254 2255 Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "", 2256 MDNode *FPMathTag = nullptr) { 2257 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag); 2258 } 2259 2260 Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "", 2261 MDNode *FPMathTag = nullptr) { 2262 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag); 2263 } 2264 2265 Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "", 2266 MDNode *FPMathTag = nullptr) { 2267 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag); 2268 } 2269 2270 Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "", 2271 MDNode *FPMathTag = nullptr) { 2272 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag); 2273 } 2274 2275 Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "", 2276 MDNode *FPMathTag = nullptr) { 2277 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag); 2278 } 2279 2280 Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "", 2281 MDNode *FPMathTag = nullptr) { 2282 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag); 2283 } 2284 2285 Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "", 2286 MDNode *FPMathTag = nullptr) { 2287 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag); 2288 } 2289 2290 Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, 2291 const Twine &Name = "") { 2292 if (auto *LC = dyn_cast<Constant>(LHS)) 2293 if (auto *RC = dyn_cast<Constant>(RHS)) 2294 return Insert(Folder.CreateICmp(P, LC, RC), Name); 2295 return Insert(new ICmpInst(P, LHS, RHS), Name); 2296 } 2297 2298 // Create a quiet floating-point comparison (i.e. one that raises an FP 2299 // exception only in the case where an input is a signaling NaN). 2300 // Note that this differs from CreateFCmpS only if IsFPConstrained is true. 2301 Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, 2302 const Twine &Name = "", MDNode *FPMathTag = nullptr) { 2303 return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false); 2304 } 2305 2306 Value *CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 2307 const Twine &Name = "", MDNode *FPMathTag = nullptr) { 2308 return CmpInst::isFPPredicate(Pred) 2309 ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag) 2310 : CreateICmp(Pred, LHS, RHS, Name); 2311 } 2312 2313 // Create a signaling floating-point comparison (i.e. one that raises an FP 2314 // exception whenever an input is any NaN, signaling or quiet). 2315 // Note that this differs from CreateFCmp only if IsFPConstrained is true. 2316 Value *CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS, 2317 const Twine &Name = "", MDNode *FPMathTag = nullptr) { 2318 return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true); 2319 } 2320 2321 private: 2322 // Helper routine to create either a signaling or a quiet FP comparison. 2323 Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS, 2324 const Twine &Name, MDNode *FPMathTag, 2325 bool IsSignaling); 2326 2327 public: 2328 CallInst *CreateConstrainedFPCmp( 2329 Intrinsic::ID ID, CmpInst::Predicate P, Value *L, Value *R, 2330 const Twine &Name = "", Optional<fp::ExceptionBehavior> Except = None); 2331 2332 //===--------------------------------------------------------------------===// 2333 // Instruction creation methods: Other Instructions 2334 //===--------------------------------------------------------------------===// 2335 2336 PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues, 2337 const Twine &Name = "") { 2338 PHINode *Phi = PHINode::Create(Ty, NumReservedValues); 2339 if (isa<FPMathOperator>(Phi)) 2340 setFPAttrs(Phi, nullptr /* MDNode* */, FMF); 2341 return Insert(Phi, Name); 2342 } 2343 2344 CallInst *CreateCall(FunctionType *FTy, Value *Callee, 2345 ArrayRef<Value *> Args = None, const Twine &Name = "", 2346 MDNode *FPMathTag = nullptr) { 2347 CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles); 2348 if (IsFPConstrained) 2349 setConstrainedFPCallAttr(CI); 2350 if (isa<FPMathOperator>(CI)) 2351 setFPAttrs(CI, FPMathTag, FMF); 2352 return Insert(CI, Name); 2353 } 2354 2355 CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args, 2356 ArrayRef<OperandBundleDef> OpBundles, 2357 const Twine &Name = "", MDNode *FPMathTag = nullptr) { 2358 CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles); 2359 if (IsFPConstrained) 2360 setConstrainedFPCallAttr(CI); 2361 if (isa<FPMathOperator>(CI)) 2362 setFPAttrs(CI, FPMathTag, FMF); 2363 return Insert(CI, Name); 2364 } 2365 2366 CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = None, 2367 const Twine &Name = "", MDNode *FPMathTag = nullptr) { 2368 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name, 2369 FPMathTag); 2370 } 2371 2372 CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args, 2373 ArrayRef<OperandBundleDef> OpBundles, 2374 const Twine &Name = "", MDNode *FPMathTag = nullptr) { 2375 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, 2376 OpBundles, Name, FPMathTag); 2377 } 2378 2379 CallInst *CreateConstrainedFPCall( 2380 Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "", 2381 Optional<RoundingMode> Rounding = None, 2382 Optional<fp::ExceptionBehavior> Except = None); 2383 2384 Value *CreateSelect(Value *C, Value *True, Value *False, 2385 const Twine &Name = "", Instruction *MDFrom = nullptr); 2386 2387 VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") { 2388 return Insert(new VAArgInst(List, Ty), Name); 2389 } 2390 2391 Value *CreateExtractElement(Value *Vec, Value *Idx, 2392 const Twine &Name = "") { 2393 if (auto *VC = dyn_cast<Constant>(Vec)) 2394 if (auto *IC = dyn_cast<Constant>(Idx)) 2395 return Insert(Folder.CreateExtractElement(VC, IC), Name); 2396 return Insert(ExtractElementInst::Create(Vec, Idx), Name); 2397 } 2398 2399 Value *CreateExtractElement(Value *Vec, uint64_t Idx, 2400 const Twine &Name = "") { 2401 return CreateExtractElement(Vec, getInt64(Idx), Name); 2402 } 2403 2404 Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, 2405 const Twine &Name = "") { 2406 if (auto *VC = dyn_cast<Constant>(Vec)) 2407 if (auto *NC = dyn_cast<Constant>(NewElt)) 2408 if (auto *IC = dyn_cast<Constant>(Idx)) 2409 return Insert(Folder.CreateInsertElement(VC, NC, IC), Name); 2410 return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name); 2411 } 2412 2413 Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx, 2414 const Twine &Name = "") { 2415 return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name); 2416 } 2417 2418 Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask, 2419 const Twine &Name = "") { 2420 SmallVector<int, 16> IntMask; 2421 ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask); 2422 return CreateShuffleVector(V1, V2, IntMask, Name); 2423 } 2424 2425 LLVM_ATTRIBUTE_DEPRECATED(Value *CreateShuffleVector(Value *V1, Value *V2, 2426 ArrayRef<uint32_t> Mask, 2427 const Twine &Name = ""), 2428 "Pass indices as 'int' instead") { 2429 SmallVector<int, 16> IntMask; 2430 IntMask.assign(Mask.begin(), Mask.end()); 2431 return CreateShuffleVector(V1, V2, IntMask, Name); 2432 } 2433 2434 /// See class ShuffleVectorInst for a description of the mask representation. 2435 Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<int> Mask, 2436 const Twine &Name = "") { 2437 if (auto *V1C = dyn_cast<Constant>(V1)) 2438 if (auto *V2C = dyn_cast<Constant>(V2)) 2439 return Insert(Folder.CreateShuffleVector(V1C, V2C, Mask), Name); 2440 return Insert(new ShuffleVectorInst(V1, V2, Mask), Name); 2441 } 2442 2443 /// Create a unary shuffle. The second vector operand of the IR instruction 2444 /// is poison. 2445 Value *CreateShuffleVector(Value *V, ArrayRef<int> Mask, 2446 const Twine &Name = "") { 2447 return CreateShuffleVector(V, PoisonValue::get(V->getType()), Mask, Name); 2448 } 2449 2450 Value *CreateExtractValue(Value *Agg, 2451 ArrayRef<unsigned> Idxs, 2452 const Twine &Name = "") { 2453 if (auto *AggC = dyn_cast<Constant>(Agg)) 2454 return Insert(Folder.CreateExtractValue(AggC, Idxs), Name); 2455 return Insert(ExtractValueInst::Create(Agg, Idxs), Name); 2456 } 2457 2458 Value *CreateInsertValue(Value *Agg, Value *Val, 2459 ArrayRef<unsigned> Idxs, 2460 const Twine &Name = "") { 2461 if (auto *AggC = dyn_cast<Constant>(Agg)) 2462 if (auto *ValC = dyn_cast<Constant>(Val)) 2463 return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name); 2464 return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name); 2465 } 2466 2467 LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses, 2468 const Twine &Name = "") { 2469 return Insert(LandingPadInst::Create(Ty, NumClauses), Name); 2470 } 2471 2472 Value *CreateFreeze(Value *V, const Twine &Name = "") { 2473 return Insert(new FreezeInst(V), Name); 2474 } 2475 2476 //===--------------------------------------------------------------------===// 2477 // Utility creation methods 2478 //===--------------------------------------------------------------------===// 2479 2480 /// Return an i1 value testing if \p Arg is null. 2481 Value *CreateIsNull(Value *Arg, const Twine &Name = "") { 2482 return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()), 2483 Name); 2484 } 2485 2486 /// Return an i1 value testing if \p Arg is not null. 2487 Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") { 2488 return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()), 2489 Name); 2490 } 2491 2492 /// Return the i64 difference between two pointer values, dividing out 2493 /// the size of the pointed-to objects. 2494 /// 2495 /// This is intended to implement C-style pointer subtraction. As such, the 2496 /// pointers must be appropriately aligned for their element types and 2497 /// pointing into the same object. 2498 Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = ""); 2499 2500 /// Create a launder.invariant.group intrinsic call. If Ptr type is 2501 /// different from pointer to i8, it's casted to pointer to i8 in the same 2502 /// address space before call and casted back to Ptr type after call. 2503 Value *CreateLaunderInvariantGroup(Value *Ptr); 2504 2505 /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is 2506 /// different from pointer to i8, it's casted to pointer to i8 in the same 2507 /// address space before call and casted back to Ptr type after call. 2508 Value *CreateStripInvariantGroup(Value *Ptr); 2509 2510 /// Return a vector value that contains the vector V reversed 2511 Value *CreateVectorReverse(Value *V, const Twine &Name = ""); 2512 2513 /// Return a vector splice intrinsic if using scalable vectors, otherwise 2514 /// return a shufflevector. If the immediate is positive, a vector is 2515 /// extracted from concat(V1, V2), starting at Imm. If the immediate 2516 /// is negative, we extract -Imm elements from V1 and the remaining 2517 /// elements from V2. Imm is a signed integer in the range 2518 /// -VL <= Imm < VL (where VL is the runtime vector length of the 2519 /// source/result vector) 2520 Value *CreateVectorSplice(Value *V1, Value *V2, int64_t Imm, 2521 const Twine &Name = ""); 2522 2523 /// Return a vector value that contains \arg V broadcasted to \p 2524 /// NumElts elements. 2525 Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = ""); 2526 2527 /// Return a vector value that contains \arg V broadcasted to \p 2528 /// EC elements. 2529 Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = ""); 2530 2531 /// Return a value that has been extracted from a larger integer type. 2532 Value *CreateExtractInteger(const DataLayout &DL, Value *From, 2533 IntegerType *ExtractedTy, uint64_t Offset, 2534 const Twine &Name); 2535 2536 Value *CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base, 2537 unsigned Dimension, unsigned LastIndex, 2538 MDNode *DbgInfo); 2539 2540 Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex, 2541 MDNode *DbgInfo); 2542 2543 Value *CreatePreserveStructAccessIndex(Type *ElTy, Value *Base, 2544 unsigned Index, unsigned FieldIndex, 2545 MDNode *DbgInfo); 2546 2547 private: 2548 /// Helper function that creates an assume intrinsic call that 2549 /// represents an alignment assumption on the provided pointer \p PtrValue 2550 /// with offset \p OffsetValue and alignment value \p AlignValue. 2551 CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL, 2552 Value *PtrValue, Value *AlignValue, 2553 Value *OffsetValue); 2554 2555 public: 2556 /// Create an assume intrinsic call that represents an alignment 2557 /// assumption on the provided pointer. 2558 /// 2559 /// An optional offset can be provided, and if it is provided, the offset 2560 /// must be subtracted from the provided pointer to get the pointer with the 2561 /// specified alignment. 2562 CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, 2563 unsigned Alignment, 2564 Value *OffsetValue = nullptr); 2565 2566 /// Create an assume intrinsic call that represents an alignment 2567 /// assumption on the provided pointer. 2568 /// 2569 /// An optional offset can be provided, and if it is provided, the offset 2570 /// must be subtracted from the provided pointer to get the pointer with the 2571 /// specified alignment. 2572 /// 2573 /// This overload handles the condition where the Alignment is dependent 2574 /// on an existing value rather than a static value. 2575 CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, 2576 Value *Alignment, 2577 Value *OffsetValue = nullptr); 2578 }; 2579 2580 /// This provides a uniform API for creating instructions and inserting 2581 /// them into a basic block: either at the end of a BasicBlock, or at a specific 2582 /// iterator location in a block. 2583 /// 2584 /// Note that the builder does not expose the full generality of LLVM 2585 /// instructions. For access to extra instruction properties, use the mutators 2586 /// (e.g. setVolatile) on the instructions after they have been 2587 /// created. Convenience state exists to specify fast-math flags and fp-math 2588 /// tags. 2589 /// 2590 /// The first template argument specifies a class to use for creating constants. 2591 /// This defaults to creating minimally folded constants. The second template 2592 /// argument allows clients to specify custom insertion hooks that are called on 2593 /// every newly created insertion. 2594 template <typename FolderTy = ConstantFolder, 2595 typename InserterTy = IRBuilderDefaultInserter> 2596 class IRBuilder : public IRBuilderBase { 2597 private: 2598 FolderTy Folder; 2599 InserterTy Inserter; 2600 2601 public: 2602 IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(), 2603 MDNode *FPMathTag = nullptr, 2604 ArrayRef<OperandBundleDef> OpBundles = None) 2605 : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles), 2606 Folder(Folder), Inserter(Inserter) {} 2607 2608 explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr, 2609 ArrayRef<OperandBundleDef> OpBundles = None) 2610 : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {} 2611 2612 explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder, 2613 MDNode *FPMathTag = nullptr, 2614 ArrayRef<OperandBundleDef> OpBundles = None) 2615 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter, 2616 FPMathTag, OpBundles), Folder(Folder) { 2617 SetInsertPoint(TheBB); 2618 } 2619 2620 explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr, 2621 ArrayRef<OperandBundleDef> OpBundles = None) 2622 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter, 2623 FPMathTag, OpBundles) { 2624 SetInsertPoint(TheBB); 2625 } 2626 2627 explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr, 2628 ArrayRef<OperandBundleDef> OpBundles = None) 2629 : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter, 2630 FPMathTag, OpBundles) { 2631 SetInsertPoint(IP); 2632 } 2633 2634 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder, 2635 MDNode *FPMathTag = nullptr, 2636 ArrayRef<OperandBundleDef> OpBundles = None) 2637 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter, 2638 FPMathTag, OpBundles), Folder(Folder) { 2639 SetInsertPoint(TheBB, IP); 2640 } 2641 2642 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, 2643 MDNode *FPMathTag = nullptr, 2644 ArrayRef<OperandBundleDef> OpBundles = None) 2645 : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter, 2646 FPMathTag, OpBundles) { 2647 SetInsertPoint(TheBB, IP); 2648 } 2649 2650 /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard 2651 /// or FastMathFlagGuard instead. 2652 IRBuilder(const IRBuilder &) = delete; 2653 getInserter()2654 InserterTy &getInserter() { return Inserter; } 2655 }; 2656 2657 // Create wrappers for C Binding types (see CBindingWrapping.h). 2658 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef) 2659 2660 } // end namespace llvm 2661 2662 #endif // LLVM_IR_IRBUILDER_H 2663