include/llvm/IR/IRBuilder.h

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