contrib/llvm-project/llvm/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       BinOp = 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     return cast<CallInst>(setFPAttrs(C, FPMathTag, UseFMF));
1483   }
1484
1485   Value *CreateNeg(Value *V, const Twine &Name = "",
1486                    bool HasNUW = false, bool HasNSW = false) {
1487     if (auto *VC = dyn_cast<Constant>(V))
1488       return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1489     BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1490     if (HasNUW) BO->setHasNoUnsignedWrap();
1491     if (HasNSW) BO->setHasNoSignedWrap();
1492     return BO;
1493   }
1494
1495   Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1496     return CreateNeg(V, Name, false, true);
1497   }
1498
1499   Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
1500     return CreateNeg(V, Name, true, false);
1501   }
1502
1503   Value *CreateFNeg(Value *V, const Twine &Name = "",
1504                     MDNode *FPMathTag = nullptr) {
1505     if (auto *VC = dyn_cast<Constant>(V))
1506       return Insert(Folder.CreateFNeg(VC), Name);
1507     return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
1508                   Name);
1509   }
1510
1511   /// Copy fast-math-flags from an instruction rather than using the builder's
1512   /// default FMF.
1513   Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
1514                        const Twine &Name = "") {
1515    if (auto *VC = dyn_cast<Constant>(V))
1516      return Insert(Folder.CreateFNeg(VC), Name);
1517    // TODO: This should return UnaryOperator::CreateFNeg(...) once we are
1518    // confident that they are optimized sufficiently.
1519    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), nullptr,
1520                             FMFSource->getFastMathFlags()),
1521                  Name);
1522   }
1523
1524   Value *CreateNot(Value *V, const Twine &Name = "") {
1525     if (auto *VC = dyn_cast<Constant>(V))
1526       return Insert(Folder.CreateNot(VC), Name);
1527     return Insert(BinaryOperator::CreateNot(V), Name);
1528   }
1529
1530   Value *CreateUnOp(Instruction::UnaryOps Opc,
1531                     Value *V, const Twine &Name = "",
1532                     MDNode *FPMathTag = nullptr) {
1533     if (auto *VC = dyn_cast<Constant>(V))
1534       return Insert(Folder.CreateUnOp(Opc, VC), Name);
1535     Instruction *UnOp = UnaryOperator::Create(Opc, V);
1536     if (isa<FPMathOperator>(UnOp))
1537       UnOp = setFPAttrs(UnOp, FPMathTag, FMF);
1538     return Insert(UnOp, Name);
1539   }
1540
1541   /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1542   /// Correct number of operands must be passed accordingly.
1543   Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1544                       const Twine &Name = "",
1545                       MDNode *FPMathTag = nullptr) {
1546     if (Instruction::isBinaryOp(Opc)) {
1547       assert(Ops.size() == 2 && "Invalid number of operands!");
1548       return CreateBinOp(static_cast<Instruction::BinaryOps>(Opc),
1549                          Ops[0], Ops[1], Name, FPMathTag);
1550     }
1551     if (Instruction::isUnaryOp(Opc)) {
1552       assert(Ops.size() == 1 && "Invalid number of operands!");
1553       return CreateUnOp(static_cast<Instruction::UnaryOps>(Opc),
1554                         Ops[0], Name, FPMathTag);
1555     }
1556     llvm_unreachable("Unexpected opcode!");
1557   }
1558
1559   //===--------------------------------------------------------------------===//
1560   // Instruction creation methods: Memory Instructions
1561   //===--------------------------------------------------------------------===//
1562
1563   AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1564                            Value *ArraySize = nullptr, const Twine &Name = "") {
1565     return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
1566   }
1567
1568   AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1569                            const Twine &Name = "") {
1570     const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1571     return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1572   }
1573
1574   /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1575   /// converting the string to 'bool' for the isVolatile parameter.
1576   LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577     return Insert(new LoadInst(Ty, Ptr), Name);
1578   }
1579
1580   LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581     return Insert(new LoadInst(Ty, Ptr), Name);
1582   }
1583
1584   LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1585                        const Twine &Name = "") {
1586     return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587   }
1588
1589   // Deprecated [opaque pointer types]
1590   LoadInst *CreateLoad(Value *Ptr, const char *Name) {
1591     return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1592   }
1593
1594   // Deprecated [opaque pointer types]
1595   LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") {
1596     return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1597   }
1598
1599   // Deprecated [opaque pointer types]
1600   LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") {
1601     return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile,
1602                       Name);
1603   }
1604
1605   StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606     return Insert(new StoreInst(Val, Ptr, isVolatile));
1607   }
1608
1609   /// Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")'
1610   /// correctly, instead of converting the string to 'bool' for the isVolatile
1611   /// parameter.
1612   LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1613                               const char *Name) {
1614     LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615     LI->setAlignment(Align);
1616     return LI;
1617   }
1618   LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1619                               const Twine &Name = "") {
1620     LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621     LI->setAlignment(Align);
1622     return LI;
1623   }
1624   LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1625                               bool isVolatile, const Twine &Name = "") {
1626     LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
1627     LI->setAlignment(Align);
1628     return LI;
1629   }
1630
1631   // Deprecated [opaque pointer types]
1632   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
1633     return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1634                              Align, Name);
1635   }
1636   // Deprecated [opaque pointer types]
1637   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align,
1638                               const Twine &Name = "") {
1639     return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1640                              Align, Name);
1641   }
1642   // Deprecated [opaque pointer types]
1643   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, bool isVolatile,
1644                               const Twine &Name = "") {
1645     return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1646                              Align, isVolatile, Name);
1647   }
1648
1649   StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
1650                                 bool isVolatile = false) {
1651     StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652     SI->setAlignment(Align);
1653     return SI;
1654   }
1655
1656   FenceInst *CreateFence(AtomicOrdering Ordering,
1657                          SyncScope::ID SSID = SyncScope::System,
1658                          const Twine &Name = "") {
1659     return Insert(new FenceInst(Context, Ordering, SSID), Name);
1660   }
1661
1662   AtomicCmpXchgInst *
1663   CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New,
1664                       AtomicOrdering SuccessOrdering,
1665                       AtomicOrdering FailureOrdering,
1666                       SyncScope::ID SSID = SyncScope::System) {
1667     return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
1668                                         FailureOrdering, SSID));
1669   }
1670
1671   AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val,
1672                                  AtomicOrdering Ordering,
1673                                  SyncScope::ID SSID = SyncScope::System) {
1674     return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
1675   }
1676
1677   Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1678                    const Twine &Name = "") {
1679     return CreateGEP(nullptr, Ptr, IdxList, Name);
1680   }
1681
1682   Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1683                    const Twine &Name = "") {
1684     if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685       // Every index must be constant.
1686       size_t i, e;
1687       for (i = 0, e = IdxList.size(); i != e; ++i)
1688         if (!isa<Constant>(IdxList[i]))
1689           break;
1690       if (i == e)
1691         return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692     }
1693     return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694   }
1695
1696   Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1697                            const Twine &Name = "") {
1698     return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1699   }
1700
1701   Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1702                            const Twine &Name = "") {
1703     if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704       // Every index must be constant.
1705       size_t i, e;
1706       for (i = 0, e = IdxList.size(); i != e; ++i)
1707         if (!isa<Constant>(IdxList[i]))
1708           break;
1709       if (i == e)
1710         return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711                       Name);
1712     }
1713     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714   }
1715
1716   Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1717     return CreateGEP(nullptr, Ptr, Idx, Name);
1718   }
1719
1720   Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721     if (auto *PC = dyn_cast<Constant>(Ptr))
1722       if (auto *IC = dyn_cast<Constant>(Idx))
1723         return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725   }
1726
1727   Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
1728                            const Twine &Name = "") {
1729     if (auto *PC = dyn_cast<Constant>(Ptr))
1730       if (auto *IC = dyn_cast<Constant>(Idx))
1731         return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1732     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1733   }
1734
1735   Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
1736     return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
1737   }
1738
1739   Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1740                             const Twine &Name = "") {
1741     Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1742
1743     if (auto *PC = dyn_cast<Constant>(Ptr))
1744       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1745
1746     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1747   }
1748
1749   Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1750                                     const Twine &Name = "") {
1751     Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1752
1753     if (auto *PC = dyn_cast<Constant>(Ptr))
1754       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1755
1756     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1757   }
1758
1759   Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1760                             const Twine &Name = "") {
1761     Value *Idxs[] = {
1762       ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1763       ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1764     };
1765
1766     if (auto *PC = dyn_cast<Constant>(Ptr))
1767       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1768
1769     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1770   }
1771
1772   Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1773                                     unsigned Idx1, const Twine &Name = "") {
1774     Value *Idxs[] = {
1775       ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1776       ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1777     };
1778
1779     if (auto *PC = dyn_cast<Constant>(Ptr))
1780       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1781
1782     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1783   }
1784
1785   Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1786                             const Twine &Name = "") {
1787     Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1788
1789     if (auto *PC = dyn_cast<Constant>(Ptr))
1790       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1791
1792     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1793   }
1794
1795   Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
1796     return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name);
1797   }
1798
1799   Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1800                                     const Twine &Name = "") {
1801     Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1802
1803     if (auto *PC = dyn_cast<Constant>(Ptr))
1804       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1805
1806     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1807   }
1808
1809   Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
1810                                     const Twine &Name = "") {
1811     return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name);
1812   }
1813
1814   Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1815                             const Twine &Name = "") {
1816     Value *Idxs[] = {
1817       ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1818       ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1819     };
1820
1821     if (auto *PC = dyn_cast<Constant>(Ptr))
1822       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1823
1824     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1825   }
1826
1827   Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1828                             const Twine &Name = "") {
1829     return CreateConstGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1830   }
1831
1832   Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1833                                     uint64_t Idx1, const Twine &Name = "") {
1834     Value *Idxs[] = {
1835       ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1836       ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1837     };
1838
1839     if (auto *PC = dyn_cast<Constant>(Ptr))
1840       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1841
1842     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1843   }
1844
1845   Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1846                                     const Twine &Name = "") {
1847     return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1848   }
1849
1850   Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1851                          const Twine &Name = "") {
1852     return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1853   }
1854
1855   Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") {
1856     return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name);
1857   }
1858
1859   /// Same as CreateGlobalString, but return a pointer with "i8*" type
1860   /// instead of a pointer to array of i8.
1861   Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
1862                                   unsigned AddressSpace = 0) {
1863     GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
1864     Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1865     Constant *Indices[] = {Zero, Zero};
1866     return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1867                                                   Indices);
1868   }
1869
1870   //===--------------------------------------------------------------------===//
1871   // Instruction creation methods: Cast/Conversion Operators
1872   //===--------------------------------------------------------------------===//
1873
1874   Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875     return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876   }
1877
1878   Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1879     return CreateCast(Instruction::ZExt, V, DestTy, Name);
1880   }
1881
1882   Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
1883     return CreateCast(Instruction::SExt, V, DestTy, Name);
1884   }
1885
1886   /// Create a ZExt or Trunc from the integer value V to DestTy. Return
1887   /// the value untouched if the type of V is already DestTy.
1888   Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
1889                            const Twine &Name = "") {
1890     assert(V->getType()->isIntOrIntVectorTy() &&
1891            DestTy->isIntOrIntVectorTy() &&
1892            "Can only zero extend/truncate integers!");
1893     Type *VTy = V->getType();
1894     if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1895       return CreateZExt(V, DestTy, Name);
1896     if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1897       return CreateTrunc(V, DestTy, Name);
1898     return V;
1899   }
1900
1901   /// Create a SExt or Trunc from the integer value V to DestTy. Return
1902   /// the value untouched if the type of V is already DestTy.
1903   Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
1904                            const Twine &Name = "") {
1905     assert(V->getType()->isIntOrIntVectorTy() &&
1906            DestTy->isIntOrIntVectorTy() &&
1907            "Can only sign extend/truncate integers!");
1908     Type *VTy = V->getType();
1909     if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1910       return CreateSExt(V, DestTy, Name);
1911     if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1912       return CreateTrunc(V, DestTy, Name);
1913     return V;
1914   }
1915
1916   Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = ""){
1917     return CreateCast(Instruction::FPToUI, V, DestTy, Name);
1918   }
1919
1920   Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = ""){
1921     return CreateCast(Instruction::FPToSI, V, DestTy, Name);
1922   }
1923
1924   Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1925     return CreateCast(Instruction::UIToFP, V, DestTy, Name);
1926   }
1927
1928   Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1929     return CreateCast(Instruction::SIToFP, V, DestTy, Name);
1930   }
1931
1932   Value *CreateFPTrunc(Value *V, Type *DestTy,
1933                        const Twine &Name = "") {
1934     return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
1935   }
1936
1937   Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
1938     return CreateCast(Instruction::FPExt, V, DestTy, Name);
1939   }
1940
1941   Value *CreatePtrToInt(Value *V, Type *DestTy,
1942                         const Twine &Name = "") {
1943     return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
1944   }
1945
1946   Value *CreateIntToPtr(Value *V, Type *DestTy,
1947                         const Twine &Name = "") {
1948     return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
1949   }
1950
1951   Value *CreateBitCast(Value *V, Type *DestTy,
1952                        const Twine &Name = "") {
1953     return CreateCast(Instruction::BitCast, V, DestTy, Name);
1954   }
1955
1956   Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
1957                              const Twine &Name = "") {
1958     return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
1959   }
1960
1961   Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
1962                              const Twine &Name = "") {
1963     if (V->getType() == DestTy)
1964       return V;
1965     if (auto *VC = dyn_cast<Constant>(V))
1966       return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
1967     return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
1968   }
1969
1970   Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
1971                              const Twine &Name = "") {
1972     if (V->getType() == DestTy)
1973       return V;
1974     if (auto *VC = dyn_cast<Constant>(V))
1975       return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
1976     return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
1977   }
1978
1979   Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
1980                               const Twine &Name = "") {
1981     if (V->getType() == DestTy)
1982       return V;
1983     if (auto *VC = dyn_cast<Constant>(V))
1984       return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
1985     return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
1986   }
1987
1988   Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
1989                     const Twine &Name = "") {
1990     if (V->getType() == DestTy)
1991       return V;
1992     if (auto *VC = dyn_cast<Constant>(V))
1993       return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
1994     return Insert(CastInst::Create(Op, V, DestTy), Name);
1995   }
1996
1997   Value *CreatePointerCast(Value *V, Type *DestTy,
1998                            const Twine &Name = "") {
1999     if (V->getType() == DestTy)
2000       return V;
2001     if (auto *VC = dyn_cast<Constant>(V))
2002       return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
2003     return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
2004   }
2005
2006   Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
2007                                              const Twine &Name = "") {
2008     if (V->getType() == DestTy)
2009       return V;
2010
2011     if (auto *VC = dyn_cast<Constant>(V)) {
2012       return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
2013                     Name);
2014     }
2015
2016     return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
2017                   Name);
2018   }
2019
2020   Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
2021                        const Twine &Name = "") {
2022     if (V->getType() == DestTy)
2023       return V;
2024     if (auto *VC = dyn_cast<Constant>(V))
2025       return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
2026     return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
2027   }
2028
2029   Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
2030                                 const Twine &Name = "") {
2031     if (V->getType() == DestTy)
2032       return V;
2033     if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
2034       return CreatePtrToInt(V, DestTy, Name);
2035     if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
2036       return CreateIntToPtr(V, DestTy, Name);
2037
2038     return CreateBitCast(V, DestTy, Name);
2039   }
2040
2041   Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
2042     if (V->getType() == DestTy)
2043       return V;
2044     if (auto *VC = dyn_cast<Constant>(V))
2045       return Insert(Folder.CreateFPCast(VC, DestTy), Name);
2046     return Insert(CastInst::CreateFPCast(V, DestTy), Name);
2047   }
2048
2049   // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
2050   // compile time error, instead of converting the string to bool for the
2051   // isSigned parameter.
2052   Value *CreateIntCast(Value *, Type *, const char *) = delete;
2053
2054   //===--------------------------------------------------------------------===//
2055   // Instruction creation methods: Compare Instructions
2056   //===--------------------------------------------------------------------===//
2057
2058   Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
2059     return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
2060   }
2061
2062   Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
2063     return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
2064   }
2065
2066   Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2067     return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
2068   }
2069
2070   Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2071     return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
2072   }
2073
2074   Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
2075     return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
2076   }
2077
2078   Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
2079     return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
2080   }
2081
2082   Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2083     return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
2084   }
2085
2086   Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2087     return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
2088   }
2089
2090   Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
2091     return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
2092   }
2093
2094   Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
2095     return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
2096   }
2097
2098   Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2099                        MDNode *FPMathTag = nullptr) {
2100     return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
2101   }
2102
2103   Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
2104                        MDNode *FPMathTag = nullptr) {
2105     return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
2106   }
2107
2108   Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
2109                        MDNode *FPMathTag = nullptr) {
2110     return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
2111   }
2112
2113   Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
2114                        MDNode *FPMathTag = nullptr) {
2115     return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
2116   }
2117
2118   Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
2119                        MDNode *FPMathTag = nullptr) {
2120     return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
2121   }
2122
2123   Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
2124                        MDNode *FPMathTag = nullptr) {
2125     return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
2126   }
2127
2128   Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
2129                        MDNode *FPMathTag = nullptr) {
2130     return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
2131   }
2132
2133   Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
2134                        MDNode *FPMathTag = nullptr) {
2135     return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
2136   }
2137
2138   Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2139                        MDNode *FPMathTag = nullptr) {
2140     return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
2141   }
2142
2143   Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
2144                        MDNode *FPMathTag = nullptr) {
2145     return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
2146   }
2147
2148   Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
2149                        MDNode *FPMathTag = nullptr) {
2150     return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
2151   }
2152
2153   Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
2154                        MDNode *FPMathTag = nullptr) {
2155     return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
2156   }
2157
2158   Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
2159                        MDNode *FPMathTag = nullptr) {
2160     return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
2161   }
2162
2163   Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
2164                        MDNode *FPMathTag = nullptr) {
2165     return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
2166   }
2167
2168   Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
2169                     const Twine &Name = "") {
2170     if (auto *LC = dyn_cast<Constant>(LHS))
2171       if (auto *RC = dyn_cast<Constant>(RHS))
2172         return Insert(Folder.CreateICmp(P, LC, RC), Name);
2173     return Insert(new ICmpInst(P, LHS, RHS), Name);
2174   }
2175
2176   Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
2177                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2178     if (auto *LC = dyn_cast<Constant>(LHS))
2179       if (auto *RC = dyn_cast<Constant>(RHS))
2180         return Insert(Folder.CreateFCmp(P, LC, RC), Name);
2181     return Insert(setFPAttrs(new FCmpInst(P, LHS, RHS), FPMathTag, FMF), Name);
2182   }
2183
2184   //===--------------------------------------------------------------------===//
2185   // Instruction creation methods: Other Instructions
2186   //===--------------------------------------------------------------------===//
2187
2188   PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
2189                      const Twine &Name = "") {
2190     return Insert(PHINode::Create(Ty, NumReservedValues), Name);
2191   }
2192
2193   CallInst *CreateCall(FunctionType *FTy, Value *Callee,
2194                        ArrayRef<Value *> Args = None, const Twine &Name = "",
2195                        MDNode *FPMathTag = nullptr) {
2196     CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2197     if (isa<FPMathOperator>(CI))
2198       CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
2199     return Insert(CI, Name);
2200   }
2201
2202   CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
2203                        ArrayRef<OperandBundleDef> OpBundles,
2204                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2205     CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2206     if (isa<FPMathOperator>(CI))
2207       CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
2208     return Insert(CI, Name);
2209   }
2210
2211   CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = None,
2212                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2213     return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
2214                       FPMathTag);
2215   }
2216
2217   CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
2218                        ArrayRef<OperandBundleDef> OpBundles,
2219                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2220     return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
2221                       OpBundles, Name, FPMathTag);
2222   }
2223
2224   // Deprecated [opaque pointer types]
2225   CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
2226                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2227     return CreateCall(
2228         cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
2229         Args, Name, FPMathTag);
2230   }
2231
2232   // Deprecated [opaque pointer types]
2233   CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
2234                        ArrayRef<OperandBundleDef> OpBundles,
2235                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2236     return CreateCall(
2237         cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
2238         Args, OpBundles, Name, FPMathTag);
2239   }
2240
2241   Value *CreateSelect(Value *C, Value *True, Value *False,
2242                       const Twine &Name = "", Instruction *MDFrom = nullptr) {
2243     if (auto *CC = dyn_cast<Constant>(C))
2244       if (auto *TC = dyn_cast<Constant>(True))
2245         if (auto *FC = dyn_cast<Constant>(False))
2246           return Insert(Folder.CreateSelect(CC, TC, FC), Name);
2247
2248     SelectInst *Sel = SelectInst::Create(C, True, False);
2249     if (MDFrom) {
2250       MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
2251       MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
2252       Sel = addBranchMetadata(Sel, Prof, Unpred);
2253     }
2254     if (isa<FPMathOperator>(Sel))
2255       Sel = cast<SelectInst>(setFPAttrs(Sel, nullptr /* MDNode* */, FMF));
2256     return Insert(Sel, Name);
2257   }
2258
2259   VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
2260     return Insert(new VAArgInst(List, Ty), Name);
2261   }
2262
2263   Value *CreateExtractElement(Value *Vec, Value *Idx,
2264                               const Twine &Name = "") {
2265     if (auto *VC = dyn_cast<Constant>(Vec))
2266       if (auto *IC = dyn_cast<Constant>(Idx))
2267         return Insert(Folder.CreateExtractElement(VC, IC), Name);
2268     return Insert(ExtractElementInst::Create(Vec, Idx), Name);
2269   }
2270
2271   Value *CreateExtractElement(Value *Vec, uint64_t Idx,
2272                               const Twine &Name = "") {
2273     return CreateExtractElement(Vec, getInt64(Idx), Name);
2274   }
2275
2276   Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
2277                              const Twine &Name = "") {
2278     if (auto *VC = dyn_cast<Constant>(Vec))
2279       if (auto *NC = dyn_cast<Constant>(NewElt))
2280         if (auto *IC = dyn_cast<Constant>(Idx))
2281           return Insert(Folder.CreateInsertElement(VC, NC, IC), Name);
2282     return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
2283   }
2284
2285   Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
2286                              const Twine &Name = "") {
2287     return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
2288   }
2289
2290   Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
2291                              const Twine &Name = "") {
2292     if (auto *V1C = dyn_cast<Constant>(V1))
2293       if (auto *V2C = dyn_cast<Constant>(V2))
2294         if (auto *MC = dyn_cast<Constant>(Mask))
2295           return Insert(Folder.CreateShuffleVector(V1C, V2C, MC), Name);
2296     return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
2297   }
2298
2299   Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<uint32_t> IntMask,
2300                              const Twine &Name = "") {
2301     Value *Mask = ConstantDataVector::get(Context, IntMask);
2302     return CreateShuffleVector(V1, V2, Mask, Name);
2303   }
2304
2305   Value *CreateExtractValue(Value *Agg,
2306                             ArrayRef<unsigned> Idxs,
2307                             const Twine &Name = "") {
2308     if (auto *AggC = dyn_cast<Constant>(Agg))
2309       return Insert(Folder.CreateExtractValue(AggC, Idxs), Name);
2310     return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
2311   }
2312
2313   Value *CreateInsertValue(Value *Agg, Value *Val,
2314                            ArrayRef<unsigned> Idxs,
2315                            const Twine &Name = "") {
2316     if (auto *AggC = dyn_cast<Constant>(Agg))
2317       if (auto *ValC = dyn_cast<Constant>(Val))
2318         return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
2319     return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
2320   }
2321
2322   LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
2323                                    const Twine &Name = "") {
2324     return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
2325   }
2326
2327   //===--------------------------------------------------------------------===//
2328   // Utility creation methods
2329   //===--------------------------------------------------------------------===//
2330
2331   /// Return an i1 value testing if \p Arg is null.
2332   Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
2333     return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
2334                         Name);
2335   }
2336
2337   /// Return an i1 value testing if \p Arg is not null.
2338   Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
2339     return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
2340                         Name);
2341   }
2342
2343   /// Return the i64 difference between two pointer values, dividing out
2344   /// the size of the pointed-to objects.
2345   ///
2346   /// This is intended to implement C-style pointer subtraction. As such, the
2347   /// pointers must be appropriately aligned for their element types and
2348   /// pointing into the same object.
2349   Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
2350     assert(LHS->getType() == RHS->getType() &&
2351            "Pointer subtraction operand types must match!");
2352     auto *ArgType = cast<PointerType>(LHS->getType());
2353     Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
2354     Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
2355     Value *Difference = CreateSub(LHS_int, RHS_int);
2356     return CreateExactSDiv(Difference,
2357                            ConstantExpr::getSizeOf(ArgType->getElementType()),
2358                            Name);
2359   }
2360
2361   /// Create a launder.invariant.group intrinsic call. If Ptr type is
2362   /// different from pointer to i8, it's casted to pointer to i8 in the same
2363   /// address space before call and casted back to Ptr type after call.
2364   Value *CreateLaunderInvariantGroup(Value *Ptr) {
2365     assert(isa<PointerType>(Ptr->getType()) &&
2366            "launder.invariant.group only applies to pointers.");
2367     // FIXME: we could potentially avoid casts to/from i8*.
2368     auto *PtrType = Ptr->getType();
2369     auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
2370     if (PtrType != Int8PtrTy)
2371       Ptr = CreateBitCast(Ptr, Int8PtrTy);
2372     Module *M = BB->getParent()->getParent();
2373     Function *FnLaunderInvariantGroup = Intrinsic::getDeclaration(
2374         M, Intrinsic::launder_invariant_group, {Int8PtrTy});
2375
2376     assert(FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
2377            FnLaunderInvariantGroup->getFunctionType()->getParamType(0) ==
2378                Int8PtrTy &&
2379            "LaunderInvariantGroup should take and return the same type");
2380
2381     CallInst *Fn = CreateCall(FnLaunderInvariantGroup, {Ptr});
2382
2383     if (PtrType != Int8PtrTy)
2384       return CreateBitCast(Fn, PtrType);
2385     return Fn;
2386   }
2387
2388   /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
2389   /// different from pointer to i8, it's casted to pointer to i8 in the same
2390   /// address space before call and casted back to Ptr type after call.
2391   Value *CreateStripInvariantGroup(Value *Ptr) {
2392     assert(isa<PointerType>(Ptr->getType()) &&
2393            "strip.invariant.group only applies to pointers.");
2394
2395     // FIXME: we could potentially avoid casts to/from i8*.
2396     auto *PtrType = Ptr->getType();
2397     auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
2398     if (PtrType != Int8PtrTy)
2399       Ptr = CreateBitCast(Ptr, Int8PtrTy);
2400     Module *M = BB->getParent()->getParent();
2401     Function *FnStripInvariantGroup = Intrinsic::getDeclaration(
2402         M, Intrinsic::strip_invariant_group, {Int8PtrTy});
2403
2404     assert(FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
2405            FnStripInvariantGroup->getFunctionType()->getParamType(0) ==
2406                Int8PtrTy &&
2407            "StripInvariantGroup should take and return the same type");
2408
2409     CallInst *Fn = CreateCall(FnStripInvariantGroup, {Ptr});
2410
2411     if (PtrType != Int8PtrTy)
2412       return CreateBitCast(Fn, PtrType);
2413     return Fn;
2414   }
2415
2416   /// Return a vector value that contains \arg V broadcasted to \p
2417   /// NumElts elements.
2418   Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") {
2419     assert(NumElts > 0 && "Cannot splat to an empty vector!");
2420
2421     // First insert it into an undef vector so we can shuffle it.
2422     Type *I32Ty = getInt32Ty();
2423     Value *Undef = UndefValue::get(VectorType::get(V->getType(), NumElts));
2424     V = CreateInsertElement(Undef, V, ConstantInt::get(I32Ty, 0),
2425                             Name + ".splatinsert");
2426
2427     // Shuffle the value across the desired number of elements.
2428     Value *Zeros = ConstantAggregateZero::get(VectorType::get(I32Ty, NumElts));
2429     return CreateShuffleVector(V, Undef, Zeros, Name + ".splat");
2430   }
2431
2432   /// Return a value that has been extracted from a larger integer type.
2433   Value *CreateExtractInteger(const DataLayout &DL, Value *From,
2434                               IntegerType *ExtractedTy, uint64_t Offset,
2435                               const Twine &Name) {
2436     auto *IntTy = cast<IntegerType>(From->getType());
2437     assert(DL.getTypeStoreSize(ExtractedTy) + Offset <=
2438                DL.getTypeStoreSize(IntTy) &&
2439            "Element extends past full value");
2440     uint64_t ShAmt = 8 * Offset;
2441     Value *V = From;
2442     if (DL.isBigEndian())
2443       ShAmt = 8 * (DL.getTypeStoreSize(IntTy) -
2444                    DL.getTypeStoreSize(ExtractedTy) - Offset);
2445     if (ShAmt) {
2446       V = CreateLShr(V, ShAmt, Name + ".shift");
2447     }
2448     assert(ExtractedTy->getBitWidth() <= IntTy->getBitWidth() &&
2449            "Cannot extract to a larger integer!");
2450     if (ExtractedTy != IntTy) {
2451       V = CreateTrunc(V, ExtractedTy, Name + ".trunc");
2452     }
2453     return V;
2454   }
2455
2456   Value *CreatePreserveArrayAccessIndex(Value *Base, unsigned Dimension,
2457                                         unsigned LastIndex) {
2458     assert(isa<PointerType>(Base->getType()) &&
2459            "Invalid Base ptr type for preserve.array.access.index.");
2460     auto *BaseType = Base->getType();
2461
2462     Value *LastIndexV = getInt32(LastIndex);
2463     Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2464     SmallVector<Value *, 4> IdxList;
2465     for (unsigned I = 0; I < Dimension; ++I)
2466       IdxList.push_back(Zero);
2467     IdxList.push_back(LastIndexV);
2468
2469     Type *ResultType =
2470         GetElementPtrInst::getGEPReturnType(Base, IdxList);
2471
2472     Module *M = BB->getParent()->getParent();
2473     Function *FnPreserveArrayAccessIndex = Intrinsic::getDeclaration(
2474         M, Intrinsic::preserve_array_access_index, {ResultType, BaseType});
2475
2476     Value *DimV = getInt32(Dimension);
2477     CallInst *Fn =
2478         CreateCall(FnPreserveArrayAccessIndex, {Base, DimV, LastIndexV});
2479
2480     return Fn;
2481   }
2482
2483   Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
2484                                         MDNode *DbgInfo) {
2485     assert(isa<PointerType>(Base->getType()) &&
2486            "Invalid Base ptr type for preserve.union.access.index.");
2487     auto *BaseType = Base->getType();
2488
2489     Module *M = BB->getParent()->getParent();
2490     Function *FnPreserveUnionAccessIndex = Intrinsic::getDeclaration(
2491         M, Intrinsic::preserve_union_access_index, {BaseType, BaseType});
2492
2493     Value *DIIndex = getInt32(FieldIndex);
2494     CallInst *Fn =
2495         CreateCall(FnPreserveUnionAccessIndex, {Base, DIIndex});
2496     Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
2497
2498     return Fn;
2499   }
2500
2501   Value *CreatePreserveStructAccessIndex(Value *Base, unsigned Index,
2502                                          unsigned FieldIndex, MDNode *DbgInfo) {
2503     assert(isa<PointerType>(Base->getType()) &&
2504            "Invalid Base ptr type for preserve.struct.access.index.");
2505     auto *BaseType = Base->getType();
2506
2507     Value *GEPIndex = getInt32(Index);
2508     Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2509     Type *ResultType =
2510         GetElementPtrInst::getGEPReturnType(Base, {Zero, GEPIndex});
2511
2512     Module *M = BB->getParent()->getParent();
2513     Function *FnPreserveStructAccessIndex = Intrinsic::getDeclaration(
2514         M, Intrinsic::preserve_struct_access_index, {ResultType, BaseType});
2515
2516     Value *DIIndex = getInt32(FieldIndex);
2517     CallInst *Fn = CreateCall(FnPreserveStructAccessIndex,
2518                               {Base, GEPIndex, DIIndex});
2519     Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
2520
2521     return Fn;
2522   }
2523
2524 private:
2525   /// Helper function that creates an assume intrinsic call that
2526   /// represents an alignment assumption on the provided Ptr, Mask, Type
2527   /// and Offset. It may be sometimes useful to do some other logic
2528   /// based on this alignment check, thus it can be stored into 'TheCheck'.
2529   CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
2530                                             Value *PtrValue, Value *Mask,
2531                                             Type *IntPtrTy, Value *OffsetValue,
2532                                             Value **TheCheck) {
2533     Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
2534
2535     if (OffsetValue) {
2536       bool IsOffsetZero = false;
2537       if (const auto *CI = dyn_cast<ConstantInt>(OffsetValue))
2538         IsOffsetZero = CI->isZero();
2539
2540       if (!IsOffsetZero) {
2541         if (OffsetValue->getType() != IntPtrTy)
2542           OffsetValue = CreateIntCast(OffsetValue, IntPtrTy, /*isSigned*/ true,
2543                                       "offsetcast");
2544         PtrIntValue = CreateSub(PtrIntValue, OffsetValue, "offsetptr");
2545       }
2546     }
2547
2548     Value *Zero = ConstantInt::get(IntPtrTy, 0);
2549     Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
2550     Value *InvCond = CreateICmpEQ(MaskedPtr, Zero, "maskcond");
2551     if (TheCheck)
2552       *TheCheck = InvCond;
2553
2554     return CreateAssumption(InvCond);
2555   }
2556
2557 public:
2558   /// Create an assume intrinsic call that represents an alignment
2559   /// assumption on the provided pointer.
2560   ///
2561   /// An optional offset can be provided, and if it is provided, the offset
2562   /// must be subtracted from the provided pointer to get the pointer with the
2563   /// specified alignment.
2564   ///
2565   /// It may be sometimes useful to do some other logic
2566   /// based on this alignment check, thus it can be stored into 'TheCheck'.
2567   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
2568                                       unsigned Alignment,
2569                                       Value *OffsetValue = nullptr,
2570                                       Value **TheCheck = nullptr) {
2571     assert(isa<PointerType>(PtrValue->getType()) &&
2572            "trying to create an alignment assumption on a non-pointer?");
2573     assert(Alignment != 0 && "Invalid Alignment");
2574     auto *PtrTy = cast<PointerType>(PtrValue->getType());
2575     Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
2576
2577     Value *Mask = ConstantInt::get(IntPtrTy, Alignment - 1);
2578     return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
2579                                            OffsetValue, TheCheck);
2580   }
2581
2582   /// Create an assume intrinsic call that represents an alignment
2583   /// assumption on the provided pointer.
2584   ///
2585   /// An optional offset can be provided, and if it is provided, the offset
2586   /// must be subtracted from the provided pointer to get the pointer with the
2587   /// specified alignment.
2588   ///
2589   /// It may be sometimes useful to do some other logic
2590   /// based on this alignment check, thus it can be stored into 'TheCheck'.
2591   ///
2592   /// This overload handles the condition where the Alignment is dependent
2593   /// on an existing value rather than a static value.
2594   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
2595                                       Value *Alignment,
2596                                       Value *OffsetValue = nullptr,
2597                                       Value **TheCheck = nullptr) {
2598     assert(isa<PointerType>(PtrValue->getType()) &&
2599            "trying to create an alignment assumption on a non-pointer?");
2600     auto *PtrTy = cast<PointerType>(PtrValue->getType());
2601     Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
2602
2603     if (Alignment->getType() != IntPtrTy)
2604       Alignment = CreateIntCast(Alignment, IntPtrTy, /*isSigned*/ false,
2605                                 "alignmentcast");
2606
2607     Value *Mask = CreateSub(Alignment, ConstantInt::get(IntPtrTy, 1), "mask");
2608
2609     return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
2610                                            OffsetValue, TheCheck);
2611   }
2612 };
2613
2614 // Create wrappers for C Binding types (see CBindingWrapping.h).
2615 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
2616
2617 } // end namespace llvm
2618
2619 #endif // LLVM_IR_IRBUILDER_H