LCOV - code coverage report
Current view: top level - include/llvm/IR - IRBuilder.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1435 1530 93.8 %
Date: 2018-10-20 13:21:21 Functions: 470 538 87.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines the IRBuilder class, which is used as a convenient way
      11             : // to create LLVM instructions with a consistent and simplified interface.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_IR_IRBUILDER_H
      16             : #define LLVM_IR_IRBUILDER_H
      17             : 
      18             : #include "llvm-c/Types.h"
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : #include "llvm/ADT/None.h"
      21             : #include "llvm/ADT/StringRef.h"
      22             : #include "llvm/ADT/Twine.h"
      23             : #include "llvm/IR/BasicBlock.h"
      24             : #include "llvm/IR/Constant.h"
      25             : #include "llvm/IR/ConstantFolder.h"
      26             : #include "llvm/IR/Constants.h"
      27             : #include "llvm/IR/DataLayout.h"
      28             : #include "llvm/IR/DebugLoc.h"
      29             : #include "llvm/IR/DerivedTypes.h"
      30             : #include "llvm/IR/Function.h"
      31             : #include "llvm/IR/GlobalVariable.h"
      32             : #include "llvm/IR/InstrTypes.h"
      33             : #include "llvm/IR/Instruction.h"
      34             : #include "llvm/IR/Instructions.h"
      35             : #include "llvm/IR/Intrinsics.h"
      36             : #include "llvm/IR/LLVMContext.h"
      37             : #include "llvm/IR/Module.h"
      38             : #include "llvm/IR/Operator.h"
      39             : #include "llvm/IR/Type.h"
      40             : #include "llvm/IR/Value.h"
      41             : #include "llvm/IR/ValueHandle.h"
      42             : #include "llvm/Support/AtomicOrdering.h"
      43             : #include "llvm/Support/CBindingWrapping.h"
      44             : #include "llvm/Support/Casting.h"
      45             : #include <cassert>
      46             : #include <cstddef>
      47             : #include <cstdint>
      48             : #include <functional>
      49             : #include <utility>
      50             : 
      51             : namespace llvm {
      52             : 
      53             : class APInt;
      54             : class MDNode;
      55             : class Use;
      56             : 
      57             : /// This provides the default implementation of the IRBuilder
      58             : /// 'InsertHelper' method that is called whenever an instruction is created by
      59             : /// IRBuilder and needs to be inserted.
      60             : ///
      61             : /// By default, this inserts the instruction at the insertion point.
      62             : class IRBuilderDefaultInserter {
      63             : protected:
      64           0 :   void InsertHelper(Instruction *I, const Twine &Name,
      65             :                     BasicBlock *BB, BasicBlock::iterator InsertPt) const {
      66           0 :     if (BB) BB->getInstList().insert(InsertPt, I);
      67           0 :     I->setName(Name);
      68           0 :   }
      69             : };
      70             : 
      71             : /// Provides an 'InsertHelper' that calls a user-provided callback after
      72             : /// performing the default insertion.
      73             : class IRBuilderCallbackInserter : IRBuilderDefaultInserter {
      74             :   std::function<void(Instruction *)> Callback;
      75             : 
      76             : public:
      77             :   IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
      78             :       : Callback(std::move(Callback)) {}
      79             : 
      80             : protected:
      81      208016 :   void InsertHelper(Instruction *I, const Twine &Name,
      82             :                     BasicBlock *BB, BasicBlock::iterator InsertPt) const {
      83      208016 :     IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
      84      208016 :     Callback(I);
      85      208016 :   }
      86             : };
      87             : 
      88             : /// Common base class shared among various IRBuilders.
      89             : class IRBuilderBase {
      90             :   DebugLoc CurDbgLocation;
      91             : 
      92             : protected:
      93             :   BasicBlock *BB;
      94             :   BasicBlock::iterator InsertPt;
      95             :   LLVMContext &Context;
      96             : 
      97             :   MDNode *DefaultFPMathTag;
      98             :   FastMathFlags FMF;
      99             : 
     100             :   ArrayRef<OperandBundleDef> DefaultOperandBundles;
     101             : 
     102             : public:
     103             :   IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
     104             :                 ArrayRef<OperandBundleDef> OpBundles = None)
     105    16964230 :       : Context(context), DefaultFPMathTag(FPMathTag),
     106    18030624 :         DefaultOperandBundles(OpBundles) {
     107             :     ClearInsertionPoint();
     108             :   }
     109             : 
     110             :   //===--------------------------------------------------------------------===//
     111             :   // Builder configuration methods
     112             :   //===--------------------------------------------------------------------===//
     113             : 
     114             :   /// Clear the insertion point: created instructions will not be
     115             :   /// inserted into a block.
     116             :   void ClearInsertionPoint() {
     117    17582678 :     BB = nullptr;
     118    15396740 :     InsertPt = BasicBlock::iterator();
     119             :   }
     120             : 
     121           0 :   BasicBlock *GetInsertBlock() const { return BB; }
     122           0 :   BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
     123           0 :   LLVMContext &getContext() const { return Context; }
     124             : 
     125             :   /// This specifies that created instructions should be appended to the
     126             :   /// end of the specified block.
     127             :   void SetInsertPoint(BasicBlock *TheBB) {
     128     6272421 :     BB = TheBB;
     129     6275267 :     InsertPt = BB->end();
     130             :   }
     131             : 
     132             :   /// This specifies that created instructions should be inserted before
     133             :   /// the specified instruction.
     134    45742876 :   void SetInsertPoint(Instruction *I) {
     135    45742876 :     BB = I->getParent();
     136    45742876 :     InsertPt = I->getIterator();
     137             :     assert(InsertPt != BB->end() && "Can't read debug loc from end()");
     138    45742876 :     SetCurrentDebugLocation(I->getDebugLoc());
     139    45742876 :   }
     140             : 
     141             :   /// This specifies that created instructions should be inserted at the
     142             :   /// specified point.
     143     1362176 :   void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
     144     1362176 :     BB = TheBB;
     145     1362176 :     InsertPt = IP;
     146     1362176 :     if (IP != TheBB->end())
     147      722096 :       SetCurrentDebugLocation(IP->getDebugLoc());
     148     1362176 :   }
     149             : 
     150             :   /// Set location information used by debugging information.
     151             :   void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); }
     152             : 
     153             :   /// Get location information used by debugging information.
     154           3 :   const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
     155             : 
     156             :   /// If this builder has a current debug location, set it on the
     157             :   /// specified instruction.
     158    19527487 :   void SetInstDebugLocation(Instruction *I) const {
     159    19527487 :     if (CurDbgLocation)
     160     2349081 :       I->setDebugLoc(CurDbgLocation);
     161    19527487 :   }
     162             : 
     163             :   /// Get the return type of the current function that we're emitting
     164             :   /// into.
     165             :   Type *getCurrentFunctionReturnType() const;
     166             : 
     167             :   /// InsertPoint - A saved insertion point.
     168             :   class InsertPoint {
     169             :     BasicBlock *Block = nullptr;
     170             :     BasicBlock::iterator Point;
     171             : 
     172             :   public:
     173             :     /// Creates a new insertion point which doesn't point to anything.
     174             :     InsertPoint() = default;
     175             : 
     176             :     /// Creates a new insertion point at the given location.
     177             :     InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
     178             :         : Block(InsertBlock), Point(InsertPoint) {}
     179             : 
     180             :     /// Returns true if this insert point is set.
     181           0 :     bool isSet() const { return (Block != nullptr); }
     182             : 
     183           0 :     BasicBlock *getBlock() const { return Block; }
     184           0 :     BasicBlock::iterator getPoint() const { return Point; }
     185             :   };
     186             : 
     187             :   /// Returns the current insert point.
     188             :   InsertPoint saveIP() const {
     189       58202 :     return InsertPoint(GetInsertBlock(), GetInsertPoint());
     190             :   }
     191             : 
     192             :   /// Returns the current insert point, clearing it in the process.
     193             :   InsertPoint saveAndClearIP() {
     194      607055 :     InsertPoint IP(GetInsertBlock(), GetInsertPoint());
     195             :     ClearInsertionPoint();
     196             :     return IP;
     197             :   }
     198             : 
     199             :   /// Sets the current insert point to a previously-saved location.
     200             :   void restoreIP(InsertPoint IP) {
     201     1084814 :     if (IP.isSet())
     202     1056016 :       SetInsertPoint(IP.getBlock(), IP.getPoint());
     203             :     else
     204             :       ClearInsertionPoint();
     205             :   }
     206             : 
     207             :   /// Get the floating point math metadata being used.
     208           0 :   MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
     209             : 
     210             :   /// Get the flags to be applied to created floating point ops
     211           0 :   FastMathFlags getFastMathFlags() const { return FMF; }
     212             : 
     213             :   /// Clear the fast-math flags.
     214             :   void clearFastMathFlags() { FMF.clear(); }
     215             : 
     216             :   /// Set the floating point math metadata to be used.
     217           1 :   void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
     218             : 
     219             :   /// Set the fast-math flags to be used with generated fp-math operators
     220      835236 :   void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }
     221             : 
     222             :   //===--------------------------------------------------------------------===//
     223             :   // RAII helpers.
     224             :   //===--------------------------------------------------------------------===//
     225             : 
     226             :   // RAII object that stores the current insertion point and restores it
     227             :   // when the object is destroyed. This includes the debug location.
     228             :   class InsertPointGuard {
     229             :     IRBuilderBase &Builder;
     230             :     AssertingVH<BasicBlock> Block;
     231             :     BasicBlock::iterator Point;
     232             :     DebugLoc DbgLoc;
     233             : 
     234             :   public:
     235      296088 :     InsertPointGuard(IRBuilderBase &B)
     236      296088 :         : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
     237      296088 :           DbgLoc(B.getCurrentDebugLocation()) {}
     238             : 
     239             :     InsertPointGuard(const InsertPointGuard &) = delete;
     240             :     InsertPointGuard &operator=(const InsertPointGuard &) = delete;
     241             : 
     242      592176 :     ~InsertPointGuard() {
     243      296088 :       Builder.restoreIP(InsertPoint(Block, Point));
     244      592176 :       Builder.SetCurrentDebugLocation(DbgLoc);
     245      296088 :     }
     246             :   };
     247             : 
     248             :   // RAII object that stores the current fast math settings and restores
     249             :   // them when the object is destroyed.
     250             :   class FastMathFlagGuard {
     251             :     IRBuilderBase &Builder;
     252             :     FastMathFlags FMF;
     253             :     MDNode *FPMathTag;
     254             : 
     255             :   public:
     256             :     FastMathFlagGuard(IRBuilderBase &B)
     257        4343 :         : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag) {}
     258             : 
     259             :     FastMathFlagGuard(const FastMathFlagGuard &) = delete;
     260             :     FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
     261             : 
     262             :     ~FastMathFlagGuard() {
     263        4343 :       Builder.FMF = FMF;
     264        4258 :       Builder.DefaultFPMathTag = FPMathTag;
     265             :     }
     266             :   };
     267             : 
     268             :   //===--------------------------------------------------------------------===//
     269             :   // Miscellaneous creation methods.
     270             :   //===--------------------------------------------------------------------===//
     271             : 
     272             :   /// Make a new global variable with initializer type i8*
     273             :   ///
     274             :   /// Make a new global variable with an initializer that has array of i8 type
     275             :   /// filled in with the null terminated string value specified.  The new global
     276             :   /// variable will be marked mergable with any others of the same contents.  If
     277             :   /// Name is specified, it is the name of the global variable created.
     278             :   GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
     279             :                                      unsigned AddressSpace = 0);
     280             : 
     281             :   /// Get a constant value representing either true or false.
     282      200630 :   ConstantInt *getInt1(bool V) {
     283      200630 :     return ConstantInt::get(getInt1Ty(), V);
     284             :   }
     285             : 
     286             :   /// Get the constant value for i1 true.
     287           0 :   ConstantInt *getTrue() {
     288        4936 :     return ConstantInt::getTrue(Context);
     289             :   }
     290             : 
     291             :   /// Get the constant value for i1 false.
     292           0 :   ConstantInt *getFalse() {
     293        5393 :     return ConstantInt::getFalse(Context);
     294             :   }
     295             : 
     296             :   /// Get a constant 8-bit value.
     297       30627 :   ConstantInt *getInt8(uint8_t C) {
     298       30627 :     return ConstantInt::get(getInt8Ty(), C);
     299             :   }
     300             : 
     301             :   /// Get a constant 16-bit value.
     302        2145 :   ConstantInt *getInt16(uint16_t C) {
     303        2145 :     return ConstantInt::get(getInt16Ty(), C);
     304             :   }
     305             : 
     306             :   /// Get a constant 32-bit value.
     307      530928 :   ConstantInt *getInt32(uint32_t C) {
     308      530928 :     return ConstantInt::get(getInt32Ty(), C);
     309             :   }
     310             : 
     311             :   /// Get a constant 64-bit value.
     312      173142 :   ConstantInt *getInt64(uint64_t C) {
     313      173142 :     return ConstantInt::get(getInt64Ty(), C);
     314             :   }
     315             : 
     316             :   /// Get a constant N-bit value, zero extended or truncated from
     317             :   /// a 64-bit value.
     318       13964 :   ConstantInt *getIntN(unsigned N, uint64_t C) {
     319       13964 :     return ConstantInt::get(getIntNTy(N), C);
     320             :   }
     321             : 
     322             :   /// Get a constant integer value.
     323           0 :   ConstantInt *getInt(const APInt &AI) {
     324       77364 :     return ConstantInt::get(Context, AI);
     325             :   }
     326             : 
     327             :   //===--------------------------------------------------------------------===//
     328             :   // Type creation methods
     329             :   //===--------------------------------------------------------------------===//
     330             : 
     331             :   /// Fetch the type representing a single bit
     332           0 :   IntegerType *getInt1Ty() {
     333      258746 :     return Type::getInt1Ty(Context);
     334             :   }
     335             : 
     336             :   /// Fetch the type representing an 8-bit integer.
     337           0 :   IntegerType *getInt8Ty() {
     338       49423 :     return Type::getInt8Ty(Context);
     339             :   }
     340             : 
     341             :   /// Fetch the type representing a 16-bit integer.
     342           0 :   IntegerType *getInt16Ty() {
     343        2219 :     return Type::getInt16Ty(Context);
     344             :   }
     345             : 
     346             :   /// Fetch the type representing a 32-bit integer.
     347           0 :   IntegerType *getInt32Ty() {
     348      558809 :     return Type::getInt32Ty(Context);
     349             :   }
     350             : 
     351             :   /// Fetch the type representing a 64-bit integer.
     352           0 :   IntegerType *getInt64Ty() {
     353      174501 :     return Type::getInt64Ty(Context);
     354             :   }
     355             : 
     356             :   /// Fetch the type representing a 128-bit integer.
     357           3 :   IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
     358             : 
     359             :   /// Fetch the type representing an N-bit integer.
     360           0 :   IntegerType *getIntNTy(unsigned N) {
     361       17702 :     return Type::getIntNTy(Context, N);
     362             :   }
     363             : 
     364             :   /// Fetch the type representing a 16-bit floating point value.
     365           0 :   Type *getHalfTy() {
     366           6 :     return Type::getHalfTy(Context);
     367             :   }
     368             : 
     369             :   /// Fetch the type representing a 32-bit floating point value.
     370           0 :   Type *getFloatTy() {
     371         403 :     return Type::getFloatTy(Context);
     372             :   }
     373             : 
     374             :   /// Fetch the type representing a 64-bit floating point value.
     375           0 :   Type *getDoubleTy() {
     376          43 :     return Type::getDoubleTy(Context);
     377             :   }
     378             : 
     379             :   /// Fetch the type representing void.
     380           0 :   Type *getVoidTy() {
     381       57039 :     return Type::getVoidTy(Context);
     382             :   }
     383             : 
     384             :   /// Fetch the type representing a pointer to an 8-bit integer value.
     385           0 :   PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
     386      132834 :     return Type::getInt8PtrTy(Context, AddrSpace);
     387             :   }
     388             : 
     389             :   /// Fetch the type representing a pointer to an integer value.
     390           0 :   IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
     391         599 :     return DL.getIntPtrType(Context, AddrSpace);
     392             :   }
     393             : 
     394             :   //===--------------------------------------------------------------------===//
     395             :   // Intrinsic creation methods
     396             :   //===--------------------------------------------------------------------===//
     397             : 
     398             :   /// Create and insert a memset to the specified pointer and the
     399             :   /// specified value.
     400             :   ///
     401             :   /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
     402             :   /// specified, it will be added to the instruction. Likewise with alias.scope
     403             :   /// and noalias tags.
     404          67 :   CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align,
     405             :                          bool isVolatile = false, MDNode *TBAATag = nullptr,
     406             :                          MDNode *ScopeTag = nullptr,
     407             :                          MDNode *NoAliasTag = nullptr) {
     408       24864 :     return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
     409          67 :                         TBAATag, ScopeTag, NoAliasTag);
     410             :   }
     411             : 
     412             :   CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
     413             :                          bool isVolatile = false, MDNode *TBAATag = nullptr,
     414             :                          MDNode *ScopeTag = nullptr,
     415             :                          MDNode *NoAliasTag = nullptr);
     416             : 
     417             :   /// Create and insert an element unordered-atomic memset of the region of
     418             :   /// memory starting at the given pointer to the given value.
     419             :   ///
     420             :   /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
     421             :   /// specified, it will be added to the instruction. Likewise with alias.scope
     422             :   /// and noalias tags.
     423             :   CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
     424             :                                                uint64_t Size, unsigned Align,
     425             :                                                uint32_t ElementSize,
     426             :                                                MDNode *TBAATag = nullptr,
     427             :                                                MDNode *ScopeTag = nullptr,
     428             :                                                MDNode *NoAliasTag = nullptr) {
     429             :     return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size), Align,
     430             :                                               ElementSize, TBAATag, ScopeTag,
     431             :                                               NoAliasTag);
     432             :   }
     433             : 
     434             :   CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
     435             :                                                Value *Size, unsigned Align,
     436             :                                                uint32_t ElementSize,
     437             :                                                MDNode *TBAATag = nullptr,
     438             :                                                MDNode *ScopeTag = nullptr,
     439             :                                                MDNode *NoAliasTag = nullptr);
     440             : 
     441             :   /// Create and insert a memcpy between the specified pointers.
     442             :   ///
     443             :   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
     444             :   /// specified, it will be added to the instruction. Likewise with alias.scope
     445             :   /// and noalias tags.
     446          35 :   CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
     447             :                          unsigned SrcAlign, uint64_t Size,
     448             :                          bool isVolatile = false, MDNode *TBAATag = nullptr,
     449             :                          MDNode *TBAAStructTag = nullptr,
     450             :                          MDNode *ScopeTag = nullptr,
     451             :                          MDNode *NoAliasTag = nullptr) {
     452         885 :     return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
     453             :                         isVolatile, TBAATag, TBAAStructTag, ScopeTag,
     454          35 :                         NoAliasTag);
     455             :   }
     456             : 
     457             :   CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
     458             :                          unsigned SrcAlign, Value *Size,
     459             :                          bool isVolatile = false, MDNode *TBAATag = nullptr,
     460             :                          MDNode *TBAAStructTag = nullptr,
     461             :                          MDNode *ScopeTag = nullptr,
     462             :                          MDNode *NoAliasTag = nullptr);
     463             : 
     464             :   /// Create and insert an element unordered-atomic memcpy between the
     465             :   /// specified pointers.
     466             :   ///
     467             :   /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
     468             :   ///
     469             :   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
     470             :   /// specified, it will be added to the instruction. Likewise with alias.scope
     471             :   /// and noalias tags.
     472             :   CallInst *CreateElementUnorderedAtomicMemCpy(
     473             :       Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
     474             :       uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
     475             :       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
     476             :       MDNode *NoAliasTag = nullptr) {
     477             :     return CreateElementUnorderedAtomicMemCpy(
     478             :         Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
     479             :         TBAAStructTag, ScopeTag, NoAliasTag);
     480             :   }
     481             : 
     482             :   CallInst *CreateElementUnorderedAtomicMemCpy(
     483             :       Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
     484             :       uint32_t ElementSize, MDNode *TBAATag = nullptr,
     485             :       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
     486             :       MDNode *NoAliasTag = nullptr);
     487             : 
     488             :   /// Create and insert a memmove between the specified
     489             :   /// pointers.
     490             :   ///
     491             :   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
     492             :   /// specified, it will be added to the instruction. Likewise with alias.scope
     493             :   /// and noalias tags.
     494             :   CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
     495             :                           uint64_t Size, bool isVolatile = false,
     496             :                           MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
     497             :                           MDNode *NoAliasTag = nullptr) {
     498           4 :     return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size), isVolatile,
     499             :                          TBAATag, ScopeTag, NoAliasTag);
     500             :   }
     501             : 
     502             :   CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
     503             :                           Value *Size, bool isVolatile = false, MDNode *TBAATag = nullptr,
     504             :                           MDNode *ScopeTag = nullptr,
     505             :                           MDNode *NoAliasTag = nullptr);
     506             : 
     507             :   /// \brief Create and insert an element unordered-atomic memmove between the
     508             :   /// specified pointers.
     509             :   ///
     510             :   /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,
     511             :   /// respectively.
     512             :   ///
     513             :   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
     514             :   /// specified, it will be added to the instruction. Likewise with alias.scope
     515             :   /// and noalias tags.
     516             :   CallInst *CreateElementUnorderedAtomicMemMove(
     517             :       Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
     518             :       uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
     519             :       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
     520             :       MDNode *NoAliasTag = nullptr) {
     521             :     return CreateElementUnorderedAtomicMemMove(
     522             :         Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
     523             :         TBAAStructTag, ScopeTag, NoAliasTag);
     524             :   }
     525             : 
     526             :   CallInst *CreateElementUnorderedAtomicMemMove(
     527             :       Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
     528             :       uint32_t ElementSize, MDNode *TBAATag = nullptr,
     529             :       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
     530             :       MDNode *NoAliasTag = nullptr);
     531             : 
     532             :   /// Create a vector fadd reduction intrinsic of the source vector.
     533             :   /// The first parameter is a scalar accumulator value for ordered reductions.
     534             :   CallInst *CreateFAddReduce(Value *Acc, Value *Src);
     535             : 
     536             :   /// Create a vector fmul reduction intrinsic of the source vector.
     537             :   /// The first parameter is a scalar accumulator value for ordered reductions.
     538             :   CallInst *CreateFMulReduce(Value *Acc, Value *Src);
     539             : 
     540             :   /// Create a vector int add reduction intrinsic of the source vector.
     541             :   CallInst *CreateAddReduce(Value *Src);
     542             : 
     543             :   /// Create a vector int mul reduction intrinsic of the source vector.
     544             :   CallInst *CreateMulReduce(Value *Src);
     545             : 
     546             :   /// Create a vector int AND reduction intrinsic of the source vector.
     547             :   CallInst *CreateAndReduce(Value *Src);
     548             : 
     549             :   /// Create a vector int OR reduction intrinsic of the source vector.
     550             :   CallInst *CreateOrReduce(Value *Src);
     551             : 
     552             :   /// Create a vector int XOR reduction intrinsic of the source vector.
     553             :   CallInst *CreateXorReduce(Value *Src);
     554             : 
     555             :   /// Create a vector integer max reduction intrinsic of the source
     556             :   /// vector.
     557             :   CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
     558             : 
     559             :   /// Create a vector integer min reduction intrinsic of the source
     560             :   /// vector.
     561             :   CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
     562             : 
     563             :   /// Create a vector float max reduction intrinsic of the source
     564             :   /// vector.
     565             :   CallInst *CreateFPMaxReduce(Value *Src, bool NoNaN = false);
     566             : 
     567             :   /// Create a vector float min reduction intrinsic of the source
     568             :   /// vector.
     569             :   CallInst *CreateFPMinReduce(Value *Src, bool NoNaN = false);
     570             : 
     571             :   /// Create a lifetime.start intrinsic.
     572             :   ///
     573             :   /// If the pointer isn't i8* it will be converted.
     574             :   CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
     575             : 
     576             :   /// Create a lifetime.end intrinsic.
     577             :   ///
     578             :   /// If the pointer isn't i8* it will be converted.
     579             :   CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
     580             : 
     581             :   /// Create a call to invariant.start intrinsic.
     582             :   ///
     583             :   /// If the pointer isn't i8* it will be converted.
     584             :   CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
     585             : 
     586             :   /// Create a call to Masked Load intrinsic
     587             :   CallInst *CreateMaskedLoad(Value *Ptr, unsigned Align, Value *Mask,
     588             :                              Value *PassThru = nullptr, const Twine &Name = "");
     589             : 
     590             :   /// Create a call to Masked Store intrinsic
     591             :   CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align,
     592             :                               Value *Mask);
     593             : 
     594             :   /// Create a call to Masked Gather intrinsic
     595             :   CallInst *CreateMaskedGather(Value *Ptrs, unsigned Align,
     596             :                                Value *Mask = nullptr,
     597             :                                Value *PassThru = nullptr,
     598             :                                const Twine& Name = "");
     599             : 
     600             :   /// Create a call to Masked Scatter intrinsic
     601             :   CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Align,
     602             :                                 Value *Mask = nullptr);
     603             : 
     604             :   /// Create an assume intrinsic call that allows the optimizer to
     605             :   /// assume that the provided condition will be true.
     606             :   CallInst *CreateAssumption(Value *Cond);
     607             : 
     608             :   /// Create a call to the experimental.gc.statepoint intrinsic to
     609             :   /// start a new statepoint sequence.
     610             :   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
     611             :                                    Value *ActualCallee,
     612             :                                    ArrayRef<Value *> CallArgs,
     613             :                                    ArrayRef<Value *> DeoptArgs,
     614             :                                    ArrayRef<Value *> GCArgs,
     615             :                                    const Twine &Name = "");
     616             : 
     617             :   /// Create a call to the experimental.gc.statepoint intrinsic to
     618             :   /// start a new statepoint sequence.
     619             :   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
     620             :                                    Value *ActualCallee, uint32_t Flags,
     621             :                                    ArrayRef<Use> CallArgs,
     622             :                                    ArrayRef<Use> TransitionArgs,
     623             :                                    ArrayRef<Use> DeoptArgs,
     624             :                                    ArrayRef<Value *> GCArgs,
     625             :                                    const Twine &Name = "");
     626             : 
     627             :   /// Conveninence function for the common case when CallArgs are filled
     628             :   /// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
     629             :   /// .get()'ed to get the Value pointer.
     630             :   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
     631             :                                    Value *ActualCallee, ArrayRef<Use> CallArgs,
     632             :                                    ArrayRef<Value *> DeoptArgs,
     633             :                                    ArrayRef<Value *> GCArgs,
     634             :                                    const Twine &Name = "");
     635             : 
     636             :   /// Create an invoke to the experimental.gc.statepoint intrinsic to
     637             :   /// start a new statepoint sequence.
     638             :   InvokeInst *
     639             :   CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
     640             :                            Value *ActualInvokee, BasicBlock *NormalDest,
     641             :                            BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
     642             :                            ArrayRef<Value *> DeoptArgs,
     643             :                            ArrayRef<Value *> GCArgs, const Twine &Name = "");
     644             : 
     645             :   /// Create an invoke to the experimental.gc.statepoint intrinsic to
     646             :   /// start a new statepoint sequence.
     647             :   InvokeInst *CreateGCStatepointInvoke(
     648             :       uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
     649             :       BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
     650             :       ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
     651             :       ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs,
     652             :       const Twine &Name = "");
     653             : 
     654             :   // Convenience function for the common case when CallArgs are filled in using
     655             :   // makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
     656             :   // get the Value *.
     657             :   InvokeInst *
     658             :   CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
     659             :                            Value *ActualInvokee, BasicBlock *NormalDest,
     660             :                            BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
     661             :                            ArrayRef<Value *> DeoptArgs,
     662             :                            ArrayRef<Value *> GCArgs, const Twine &Name = "");
     663             : 
     664             :   /// Create a call to the experimental.gc.result intrinsic to extract
     665             :   /// the result from a call wrapped in a statepoint.
     666             :   CallInst *CreateGCResult(Instruction *Statepoint,
     667             :                            Type *ResultType,
     668             :                            const Twine &Name = "");
     669             : 
     670             :   /// Create a call to the experimental.gc.relocate intrinsics to
     671             :   /// project the relocated value of one pointer from the statepoint.
     672             :   CallInst *CreateGCRelocate(Instruction *Statepoint,
     673             :                              int BaseOffset,
     674             :                              int DerivedOffset,
     675             :                              Type *ResultType,
     676             :                              const Twine &Name = "");
     677             : 
     678             :   /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
     679             :   /// type.
     680             :   CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
     681             :                                  Instruction *FMFSource = nullptr,
     682             :                                  const Twine &Name = "");
     683             : 
     684             :   /// Create a call to intrinsic \p ID with 2 operands which is mangled on the
     685             :   /// first type.
     686             :   CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
     687             :                                   Instruction *FMFSource = nullptr,
     688             :                                   const Twine &Name = "");
     689             : 
     690             :   /// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If
     691             :   /// \p FMFSource is provided, copy fast-math-flags from that instruction to
     692             :   /// the intrinsic.
     693             :   CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
     694             :                             ArrayRef<Value *> Args,
     695             :                             Instruction *FMFSource = nullptr,
     696             :                             const Twine &Name = "");
     697             : 
     698             :   /// Create call to the minnum intrinsic.
     699             :   CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
     700          15 :     return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
     701             :   }
     702             : 
     703             :   /// Create call to the maxnum intrinsic.
     704             :   CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
     705           5 :     return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
     706             :   }
     707             : 
     708             :   /// Create call to the minimum intrinsic.
     709             :   CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
     710           1 :     return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
     711             :   }
     712             : 
     713             :   /// Create call to the maximum intrinsic.
     714             :   CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
     715           1 :     return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
     716             :   }
     717             : 
     718             : private:
     719             :   /// Create a call to a masked intrinsic with given Id.
     720             :   CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
     721             :                                   ArrayRef<Type *> OverloadedTypes,
     722             :                                   const Twine &Name = "");
     723             : 
     724             :   Value *getCastedInt8PtrValue(Value *Ptr);
     725             : };
     726             : 
     727             : /// This provides a uniform API for creating instructions and inserting
     728             : /// them into a basic block: either at the end of a BasicBlock, or at a specific
     729             : /// iterator location in a block.
     730             : ///
     731             : /// Note that the builder does not expose the full generality of LLVM
     732             : /// instructions.  For access to extra instruction properties, use the mutators
     733             : /// (e.g. setVolatile) on the instructions after they have been
     734             : /// created. Convenience state exists to specify fast-math flags and fp-math
     735             : /// tags.
     736             : ///
     737             : /// The first template argument specifies a class to use for creating constants.
     738             : /// This defaults to creating minimally folded constants.  The second template
     739             : /// argument allows clients to specify custom insertion hooks that are called on
     740             : /// every newly created insertion.
     741             : template <typename T = ConstantFolder,
     742             :           typename Inserter = IRBuilderDefaultInserter>
     743     3643545 : class IRBuilder : public IRBuilderBase, public Inserter {
     744             :   T Folder;
     745             : 
     746             : public:
     747     1242682 :   IRBuilder(LLVMContext &C, const T &F, Inserter I = Inserter(),
     748             :             MDNode *FPMathTag = nullptr,
     749             :             ArrayRef<OperandBundleDef> OpBundles = None)
     750             :       : IRBuilderBase(C, FPMathTag, OpBundles), Inserter(std::move(I)),
     751     1127800 :         Folder(F) {}
     752             : 
     753       51311 :   explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
     754             :                      ArrayRef<OperandBundleDef> OpBundles = None)
     755             :       : IRBuilderBase(C, FPMathTag, OpBundles) {}
     756             : 
     757             :   explicit IRBuilder(BasicBlock *TheBB, const T &F, MDNode *FPMathTag = nullptr,
     758             :                      ArrayRef<OperandBundleDef> OpBundles = None)
     759             :       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
     760             :     SetInsertPoint(TheBB);
     761             :   }
     762             : 
     763     2500406 :   explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
     764             :                      ArrayRef<OperandBundleDef> OpBundles = None)
     765     2500406 :       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
     766             :     SetInsertPoint(TheBB);
     767             :   }
     768             : 
     769    14150715 :   explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
     770             :                      ArrayRef<OperandBundleDef> OpBundles = None)
     771    14150715 :       : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
     772    14150715 :     SetInsertPoint(IP);
     773    14150715 :   }
     774       11197 : 
     775         567 :   IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T &F,
     776       11197 :             MDNode *FPMathTag = nullptr,
     777       11197 :             ArrayRef<OperandBundleDef> OpBundles = None)
     778       11764 :       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
     779        2634 :     SetInsertPoint(TheBB, IP);
     780         567 :   }
     781        2067 : 
     782        4631 :   IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
     783        2067 :             MDNode *FPMathTag = nullptr,
     784             :             ArrayRef<OperandBundleDef> OpBundles = None)
     785        2564 :       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
     786        2564 :     SetInsertPoint(TheBB, IP);
     787        2564 :   }
     788             : 
     789             :   /// Get the constant folder being used.
     790             :   const T &getFolder() { return Folder; }
     791             : 
     792             :   /// Insert and return the specified instruction.
     793             :   template<typename InstTy>
     794    17874461 :   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
     795    19091197 :     this->InsertHelper(I, Name, BB, InsertPt);
     796    19126668 :     this->SetInstDebugLocation(I);
     797    17874461 :     return I;
     798             :   }
     799      888343 : 
     800      888343 :   /// No-op overload to handle constants.
     801      888343 :   Constant *Insert(Constant *C, const Twine& = "") const {
     802      888343 :     return C;
     803             :   }
     804      528262 : 
     805      631997 :   //===--------------------------------------------------------------------===//
     806      632060 :   // Instruction creation methods: Terminators
     807      528262 :   //===--------------------------------------------------------------------===//
     808           0 : 
     809     3158531 : private:
     810     3158531 :   /// Helper to add branch weight and unpredictable metadata onto an
     811     3158531 :   /// instruction.
     812     3158531 :   /// \returns The annotated instruction.
     813             :   template <typename InstTy>
     814     3169138 :   InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
     815     3169138 :     if (Weights)
     816     3169138 :       I->setMetadata(LLVMContext::MD_prof, Weights);
     817     3169138 :     if (Unpredictable)
     818           0 :       I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
     819      139027 :     return I;
     820      139027 :   }
     821      139027 : 
     822      139027 : public:
     823           0 :   /// Create a 'ret void' instruction.
     824      152306 :   ReturnInst *CreateRetVoid() {
     825      152306 :     return Insert(ReturnInst::Create(Context));
     826      152114 :   }
     827      152114 : 
     828           0 :   /// Create a 'ret <val>' instruction.
     829      894158 :   ReturnInst *CreateRet(Value *V) {
     830      894158 :     return Insert(ReturnInst::Create(Context, V));
     831      893807 :   }
     832      893807 : 
     833           0 :   /// Create a sequence of N insertvalue instructions,
     834      434077 :   /// with one Value from the retVals array each, that build a aggregate
     835      434077 :   /// return value one value at a time, and a ret instruction to return
     836      434077 :   /// the resulting aggregate value.
     837      434077 :   ///
     838           8 :   /// This is a convenience function for code that uses aggregate return values
     839     1208772 :   /// as a vehicle for having multiple return values.
     840     1208764 :   ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
     841     1208764 :     Value *V = UndefValue::get(getCurrentFunctionReturnType());
     842     1208764 :     for (unsigned i = 0; i != N; ++i)
     843           0 :       V = CreateInsertValue(V, retVals[i], i, "mrv");
     844     2647112 :     return Insert(ReturnInst::Create(Context, V));
     845     2647117 :   }
     846     2647117 : 
     847     2647112 :   /// Create an unconditional 'br label X' instruction.
     848        1518 :   BranchInst *CreateBr(BasicBlock *Dest) {
     849      998453 :     return Insert(BranchInst::Create(Dest));
     850      996994 :   }
     851      996994 : 
     852      996935 :   /// Create a conditional 'br Cond, TrueDest, FalseDest'
     853           0 :   /// instruction.
     854      158529 :   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
     855      155687 :                            MDNode *BranchWeights = nullptr,
     856      155687 :                            MDNode *Unpredictable = nullptr) {
     857      155687 :     return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
     858        2842 :                                     BranchWeights, Unpredictable));
     859     1285536 :   }
     860     1285614 : 
     861     1285458 :   /// Create a conditional 'br Cond, TrueDest, FalseDest'
     862     1297102 :   /// instruction. Copy branch meta data if available.
     863       11860 :   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
     864      221484 :                            Instruction *MDSrc) {
     865      221512 :     BranchInst *Br = BranchInst::Create(True, False, Cond);
     866      221668 :     if (MDSrc) {
     867      221537 :       unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
     868        5137 :                         LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
     869     1977231 :       Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
     870     1977146 :     }
     871     1977359 :     return Insert(Br);
     872     1982280 :   }
     873          28 : 
     874         234 :   /// Create a switch instruction with the specified value, default dest,
     875         322 :   /// and with a hint for the number of cases that will be added (for efficient
     876         146 :   /// allocation).
     877         669 :   SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
     878      784103 :                            MDNode *BranchWeights = nullptr,
     879      789260 :                            MDNode *Unpredictable = nullptr) {
     880        4038 :     return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
     881        4441 :                                     BranchWeights, Unpredictable));
     882        3918 :   }
     883        1223 : 
     884        6511 :   /// Create an indirect branch instruction with the specified address
     885        5142 :   /// operand, with an optional hint for the number of destinations that will be
     886        6122 :   /// added (for efficient allocation).
     887        6122 :   IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
     888        1767 :     return Insert(IndirectBrInst::Create(Addr, NumDests));
     889        2390 :   }
     890        1867 : 
     891         707 :   /// Create an invoke instruction.
     892         761 :   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
     893         160 :                            BasicBlock *UnwindDest,
     894        1399 :                            ArrayRef<Value *> Args = None,
     895        1079 :                            const Twine &Name = "") {
     896        1066 :     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args),
     897        1104 :                   Name);
     898         446 :   }
     899        9223 :   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
     900          18 :                            BasicBlock *UnwindDest, ArrayRef<Value *> Args,
     901          18 :                            ArrayRef<OperandBundleDef> OpBundles,
     902          66 :                            const Twine &Name = "") {
     903       10310 :     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args,
     904         933 :                                      OpBundles), Name);
     905           0 :   }
     906           0 : 
     907         180 :   ResumeInst *CreateResume(Value *Exn) {
     908           2 :     return Insert(ResumeInst::Create(Exn));
     909        2284 :   }
     910           0 : 
     911           0 :   CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
     912      793579 :                                       BasicBlock *UnwindBB = nullptr) {
     913     1187228 :     return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
     914      782901 :   }
     915             : 
     916           1 :   CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
     917             :                                      unsigned NumHandlers,
     918      498849 :                                      const Twine &Name = "") {
     919      437627 :     return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
     920      323493 :                   Name);
     921         322 :   }
     922       61033 : 
     923         375 :   CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
     924      323866 :                                const Twine &Name = "") {
     925         323 :     return Insert(CatchPadInst::Create(ParentPad, Args), Name);
     926         160 :   }
     927           0 : 
     928        6171 :   CleanupPadInst *CreateCleanupPad(Value *ParentPad,
     929         144 :                                    ArrayRef<Value *> Args = None,
     930         160 :                                    const Twine &Name = "") {
     931           0 :     return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
     932        6178 :   }
     933         149 : 
     934       11970 :   CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
     935           1 :     return Insert(CatchReturnInst::Create(CatchPad, BB));
     936           0 :   }
     937           2 : 
     938       15168 :   UnreachableInst *CreateUnreachable() {
     939        3201 :     return Insert(new UnreachableInst(Context));
     940           0 :   }
     941        4777 : 
     942      118153 :   //===--------------------------------------------------------------------===//
     943      118335 :   // Instruction creation methods: Binary Operators
     944           3 :   //===--------------------------------------------------------------------===//
     945        4605 : private:
     946      150334 :   BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
     947          12 :                                           Value *LHS, Value *RHS,
     948          39 :                                           const Twine &Name,
     949           2 :                                           bool HasNUW, bool HasNSW) {
     950      150331 :     BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
     951      152964 :     if (HasNUW) BO->setHasNoUnsignedWrap();
     952      153267 :     if (HasNSW) BO->setHasNoSignedWrap();
     953      150871 :     return BO;
     954          83 :   }
     955        2634 : 
     956        2834 :   Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
     957        3228 :                           FastMathFlags FMF) const {
     958        3097 :     if (!FPMD)
     959        2956 :       FPMD = DefaultFPMathTag;
     960         370 :     if (FPMD)
     961         170 :       I->setMetadata(LLVMContext::MD_fpmath, FPMD);
     962          94 :     I->setFastMathFlags(FMF);
     963           0 :     return I;
     964         253 :   }
     965         250 : 
     966         688 :   Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
     967        1022 :                       Value *R, const Twine &Name = nullptr) const {
     968           0 :     auto *LC = dyn_cast<Constant>(L);
     969           0 :     auto *RC = dyn_cast<Constant>(R);
     970         438 :     return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
     971        1210 :   }
     972        1210 : 
     973        1210 : public:
     974      146101 :   Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
     975           0 :                    bool HasNUW = false, bool HasNSW = false) {
     976         101 :     if (auto *LC = dyn_cast<Constant>(LHS))
     977           0 :       if (auto *RC = dyn_cast<Constant>(RHS))
     978        1981 :         return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
     979           0 :     return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
     980      146125 :                                    HasNUW, HasNSW);
     981         103 :   }
     982         127 : 
     983         127 :   Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
     984          24 :     return CreateAdd(LHS, RHS, Name, false, true);
     985          48 :   }
     986        2761 : 
     987       45366 :   Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
     988      593081 :     return CreateAdd(LHS, RHS, Name, true, false);
     989           8 :   }
     990          78 : 
     991        2407 :   Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
     992          95 :                    bool HasNUW = false, bool HasNSW = false) {
     993      547867 :     if (auto *LC = dyn_cast<Constant>(LHS))
     994        1040 :       if (auto *RC = dyn_cast<Constant>(RHS))
     995         141 :         return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
     996         608 :     return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
     997        2397 :                                    HasNUW, HasNSW);
     998         579 :   }
     999           0 : 
    1000         707 :   Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
    1001        1348 :     return CreateSub(LHS, RHS, Name, false, true);
    1002         503 :   }
    1003         801 : 
    1004       53824 :   Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
    1005       55780 :     return CreateSub(LHS, RHS, Name, true, false);
    1006        1239 :   }
    1007         844 : 
    1008        4756 :   Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
    1009         635 :                    bool HasNUW = false, bool HasNSW = false) {
    1010        3002 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1011        1109 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1012       38855 :         return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
    1013      124918 :     return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
    1014      124443 :                                    HasNUW, HasNSW);
    1015        2655 :   }
    1016       34423 : 
    1017       34934 :   Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
    1018       32030 :     return CreateMul(LHS, RHS, Name, false, true);
    1019       31818 :   }
    1020          77 : 
    1021        1366 :   Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
    1022        2546 :     return CreateMul(LHS, RHS, Name, true, false);
    1023         429 :   }
    1024         658 : 
    1025         928 :   Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
    1026        2845 :                     bool isExact = false) {
    1027        2327 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1028        1699 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1029        1469 :         return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
    1030       97836 :     if (!isExact)
    1031         792 :       return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
    1032        3656 :     return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
    1033        3712 :   }
    1034       98348 : 
    1035       98389 :   Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
    1036       97600 :     return CreateUDiv(LHS, RHS, Name, true);
    1037       97607 :   }
    1038        1200 : 
    1039         688 :   Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
    1040       65612 :                     bool isExact = false) {
    1041         252 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1042          11 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1043         245 :         return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
    1044       66830 :     if (!isExact)
    1045       65633 :       return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
    1046       65662 :     return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
    1047       66065 :   }
    1048        1196 : 
    1049          40 :   Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
    1050          44 :     return CreateSDiv(LHS, RHS, Name, true);
    1051           1 :   }
    1052          96 : 
    1053          59 :   Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
    1054          83 :     if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) return V;
    1055         323 :     return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
    1056          44 :   }
    1057           0 : 
    1058      125845 :   Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
    1059          67 :     if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) return V;
    1060          33 :     return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
    1061         221 :   }
    1062       28695 : 
    1063        1517 :   Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
    1064       97603 :                    bool HasNUW = false, bool HasNSW = false) {
    1065         218 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1066           1 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1067        1881 :         return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
    1068        2238 :     return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
    1069        1620 :                                    HasNUW, HasNSW);
    1070           0 :   }
    1071          35 : 
    1072        1644 :   Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
    1073         515 :                    bool HasNUW = false, bool HasNSW = false) {
    1074       38725 :     return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
    1075          74 :                      HasNUW, HasNSW);
    1076         683 :   }
    1077         331 : 
    1078       92040 :   Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
    1079       28256 :                    bool HasNUW = false, bool HasNSW = false) {
    1080       31896 :     return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
    1081         167 :                      HasNUW, HasNSW);
    1082        1196 :   }
    1083       21454 : 
    1084        8905 :   Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
    1085      155667 :                     bool isExact = false) {
    1086          53 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1087          33 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1088        1357 :         return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
    1089       90858 :     if (!isExact)
    1090        1661 :       return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
    1091       60490 :     return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
    1092          13 :   }
    1093         921 : 
    1094          49 :   Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
    1095       99201 :                     bool isExact = false) {
    1096          41 :     return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
    1097          19 :   }
    1098          60 : 
    1099         958 :   Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
    1100          38 :                     bool isExact = false) {
    1101         989 :     return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
    1102          12 :   }
    1103         739 : 
    1104         323 :   Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
    1105           3 :                     bool isExact = false) {
    1106          57 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1107           8 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1108          65 :         return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
    1109         298 :     if (!isExact)
    1110         304 :       return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
    1111           9 :     return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
    1112       15759 :   }
    1113           8 : 
    1114         204 :   Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
    1115         532 :                     bool isExact = false) {
    1116           8 :     return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
    1117          70 :   }
    1118         277 : 
    1119       18858 :   Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
    1120         663 :                     bool isExact = false) {
    1121           5 :     return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
    1122         509 :   }
    1123       12227 : 
    1124       10945 :   Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
    1125        6902 :     if (auto *RC = dyn_cast<Constant>(RHS)) {
    1126        3390 :       if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
    1127          25 :         return LHS;  // LHS & -1 -> LHS
    1128           2 :       if (auto *LC = dyn_cast<Constant>(LHS))
    1129         363 :         return Insert(Folder.CreateAnd(LC, RC), Name);
    1130          52 :     }
    1131        3725 :     return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
    1132          80 :   }
    1133       14056 : 
    1134          42 :   Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
    1135           8 :     return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
    1136          19 :   }
    1137           9 : 
    1138       15984 :   Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
    1139         339 :     return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
    1140       14360 :   }
    1141         273 : 
    1142        2781 :   Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
    1143           0 :     if (auto *RC = dyn_cast<Constant>(RHS)) {
    1144       15932 :       if (RC->isNullValue())
    1145          22 :         return LHS;  // LHS | 0 -> LHS
    1146          10 :       if (auto *LC = dyn_cast<Constant>(LHS))
    1147        4027 :         return Insert(Folder.CreateOr(LC, RC), Name);
    1148        4232 :     }
    1149        5645 :     return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
    1150         184 :   }
    1151           5 : 
    1152        1391 :   Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
    1153        2681 :     return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
    1154        2788 :   }
    1155        1513 : 
    1156        3842 :   Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
    1157        6142 :     return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
    1158           4 :   }
    1159         277 : 
    1160        1062 :   Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
    1161        3756 :     if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) return V;
    1162        1045 :     return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
    1163        5120 :   }
    1164         853 : 
    1165          83 :   Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
    1166        1091 :     return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
    1167           4 :   }
    1168          43 : 
    1169         156 :   Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
    1170         156 :     return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
    1171          64 :   }
    1172         308 : 
    1173          84 :   Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
    1174         817 :                     MDNode *FPMD = nullptr) {
    1175         610 :     if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
    1176         672 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
    1177         144 :     return Insert(I, Name);
    1178        4808 :   }
    1179         605 : 
    1180          18 :   /// Copy fast-math-flags from an instruction rather than using the builder's
    1181          21 :   /// default FMF.
    1182          47 :   Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
    1183        4830 :                        const Twine &Name = "") {
    1184        5632 :     if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
    1185         411 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
    1186        1001 :                                 FMFSource->getFastMathFlags());
    1187             :     return Insert(I, Name);
    1188         976 :   }
    1189         193 : 
    1190         288 :   Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
    1191         696 :                     MDNode *FPMD = nullptr) {
    1192         798 :     if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
    1193         118 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
    1194         930 :     return Insert(I, Name);
    1195        1203 :   }
    1196         440 : 
    1197          56 :   /// Copy fast-math-flags from an instruction rather than using the builder's
    1198        1468 :   /// default FMF.
    1199           4 :   Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
    1200           0 :                        const Twine &Name = "") {
    1201           0 :     if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
    1202         568 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
    1203        1454 :                                 FMFSource->getFastMathFlags());
    1204        1488 :     return Insert(I, Name);
    1205         300 :   }
    1206         601 : 
    1207        1237 :   Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
    1208           4 :                     MDNode *FPMD = nullptr) {
    1209        5020 :     if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
    1210        5001 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
    1211         626 :     return Insert(I, Name);
    1212         293 :   }
    1213         845 : 
    1214          11 :   /// Copy fast-math-flags from an instruction rather than using the builder's
    1215         642 :   /// default FMF.
    1216         600 :   Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
    1217        2054 :                        const Twine &Name = "") {
    1218       30528 :     if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
    1219        1414 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
    1220       41639 :                                 FMFSource->getFastMathFlags());
    1221          24 :     return Insert(I, Name);
    1222          11 :   }
    1223        1922 : 
    1224        1881 :   Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
    1225       28511 :                     MDNode *FPMD = nullptr) {
    1226         411 :     if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
    1227         431 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
    1228         410 :     return Insert(I, Name);
    1229          18 :   }
    1230         255 : 
    1231          18 :   /// Copy fast-math-flags from an instruction rather than using the builder's
    1232         120 :   /// default FMF.
    1233         124 :   Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
    1234         108 :                        const Twine &Name = "") {
    1235         321 :     if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
    1236        8772 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr,
    1237         204 :                                 FMFSource->getFastMathFlags());
    1238        3548 :     return Insert(I, Name);
    1239             :   }
    1240             : 
    1241        2234 :   Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
    1242             :                     MDNode *FPMD = nullptr) {
    1243        6180 :     if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
    1244             :     Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
    1245           2 :     return Insert(I, Name);
    1246             :   }
    1247           2 : 
    1248           4 :   /// Copy fast-math-flags from an instruction rather than using the builder's
    1249           0 :   /// default FMF.
    1250          12 :   Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
    1251           4 :                        const Twine &Name = "") {
    1252          12 :     if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
    1253           8 :     Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
    1254        1955 :                                 FMFSource->getFastMathFlags());
    1255        1947 :     return Insert(I, Name);
    1256        1916 :   }
    1257           0 : 
    1258         480 :   Value *CreateBinOp(Instruction::BinaryOps Opc,
    1259             :                      Value *LHS, Value *RHS, const Twine &Name = "",
    1260             :                      MDNode *FPMathTag = nullptr) {
    1261         480 :     if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
    1262         474 :     Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
    1263         474 :     if (isa<FPMathOperator>(BinOp))
    1264        6791 :       BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
    1265         474 :     return Insert(BinOp, Name);
    1266          12 :   }
    1267        6790 : 
    1268        7211 :   Value *CreateNeg(Value *V, const Twine &Name = "",
    1269        6778 :                    bool HasNUW = false, bool HasNSW = false) {
    1270          12 :     if (auto *VC = dyn_cast<Constant>(V))
    1271        6784 :       return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
    1272        5876 :     BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
    1273         427 :     if (HasNUW) BO->setHasNoUnsignedWrap();
    1274         474 :     if (HasNSW) BO->setHasNoSignedWrap();
    1275        5448 :     return BO;
    1276        5402 :   }
    1277        5448 : 
    1278        3080 :   Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
    1279        5411 :     return CreateNeg(V, Name, false, true);
    1280           0 :   }
    1281             : 
    1282           4 :   Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
    1283           3 :     return CreateNeg(V, Name, true, false);
    1284          11 :   }
    1285           3 : 
    1286         879 :   Value *CreateFNeg(Value *V, const Twine &Name = "",
    1287          15 :                     MDNode *FPMathTag = nullptr) {
    1288          52 :     if (auto *VC = dyn_cast<Constant>(V))
    1289           2 :       return Insert(Folder.CreateFNeg(VC), Name);
    1290        1727 :     return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
    1291         862 :                   Name);
    1292          37 :   }
    1293          42 : 
    1294         455 :   Value *CreateNot(Value *V, const Twine &Name = "") {
    1295           0 :     if (auto *VC = dyn_cast<Constant>(V))
    1296          23 :       return Insert(Folder.CreateNot(VC), Name);
    1297         805 :     return Insert(BinaryOperator::CreateNot(V), Name);
    1298           5 :   }
    1299        5535 : 
    1300           5 :   //===--------------------------------------------------------------------===//
    1301       10721 :   // Instruction creation methods: Memory Instructions
    1302        5527 :   //===--------------------------------------------------------------------===//
    1303       10732 : 
    1304        5185 :   AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
    1305        5185 :                            Value *ArraySize = nullptr, const Twine &Name = "") {
    1306          14 :     return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
    1307          19 :   }
    1308        1593 : 
    1309        1327 :   AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
    1310          14 :                            const Twine &Name = "") {
    1311        3023 :     const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
    1312        2731 :     return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
    1313        1421 :   }
    1314         699 : 
    1315        1421 :   /// Provided to resolve 'CreateLoad(Ptr, "...")' correctly, instead of
    1316        4031 :   /// converting the string to 'bool' for the isVolatile parameter.
    1317        1646 :   LoadInst *CreateLoad(Value *Ptr, const char *Name) {
    1318        9663 :     return Insert(new LoadInst(Ptr), Name);
    1319        3222 :   }
    1320      109473 : 
    1321      276740 :   LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") {
    1322      276737 :     return Insert(new LoadInst(Ptr), Name);
    1323      101851 :   }
    1324       99517 : 
    1325      100555 :   LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
    1326        2148 :     return Insert(new LoadInst(Ty, Ptr), Name);
    1327       99519 :   }
    1328           3 : 
    1329        3257 :   LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") {
    1330        3264 :     return Insert(new LoadInst(Ptr, nullptr, isVolatile), Name);
    1331        1133 :   }
    1332      510795 : 
    1333      772272 :   StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
    1334      263383 :     return Insert(new StoreInst(Val, Ptr, isVolatile));
    1335         899 :   }
    1336        1456 : 
    1337         964 :   /// Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")'
    1338          57 :   /// correctly, instead of converting the string to 'bool' for the isVolatile
    1339        2237 :   /// parameter.
    1340        1660 :   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
    1341         192 :     LoadInst *LI = CreateLoad(Ptr, Name);
    1342         234 :     LI->setAlignment(Align);
    1343          53 :     return LI;
    1344         276 :   }
    1345           0 :   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align,
    1346         304 :                               const Twine &Name = "") {
    1347       43087 :     LoadInst *LI = CreateLoad(Ptr, Name);
    1348       42783 :     LI->setAlignment(Align);
    1349          11 :     return LI;
    1350          47 :   }
    1351          25 :   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, bool isVolatile,
    1352         436 :                               const Twine &Name = "") {
    1353          59 :     LoadInst *LI = CreateLoad(Ptr, isVolatile, Name);
    1354         158 :     LI->setAlignment(Align);
    1355        1534 :     return LI;
    1356      510738 :   }
    1357      509491 : 
    1358         313 :   StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
    1359         505 :                                 bool isVolatile = false) {
    1360        2936 :     StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
    1361        3165 :     SI->setAlignment(Align);
    1362        7279 :     return SI;
    1363        3954 :   }
    1364        8613 : 
    1365        8945 :   FenceInst *CreateFence(AtomicOrdering Ordering,
    1366        8941 :                          SyncScope::ID SSID = SyncScope::System,
    1367        8978 :                          const Twine &Name = "") {
    1368      211873 :     return Insert(new FenceInst(Context, Ordering, SSID), Name);
    1369      171715 :   }
    1370       11434 : 
    1371       32644 :   AtomicCmpXchgInst *
    1372       19195 :   CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New,
    1373       20766 :                       AtomicOrdering SuccessOrdering,
    1374        3998 :                       AtomicOrdering FailureOrdering,
    1375         898 :                       SyncScope::ID SSID = SyncScope::System) {
    1376         924 :     return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
    1377       56576 :                                         FailureOrdering, SSID));
    1378       57867 :   }
    1379        4455 : 
    1380        2156 :   AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val,
    1381        2691 :                                  AtomicOrdering Ordering,
    1382        2936 :                                  SyncScope::ID SSID = SyncScope::System) {
    1383        6798 :     return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
    1384        8309 :   }
    1385         693 : 
    1386        4636 :   Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
    1387        2525 :                    const Twine &Name = "") {
    1388       24975 :     return CreateGEP(nullptr, Ptr, IdxList, Name);
    1389      131269 :   }
    1390      111381 : 
    1391        7119 :   Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
    1392       10133 :                    const Twine &Name = "") {
    1393      176862 :     if (auto *PC = dyn_cast<Constant>(Ptr)) {
    1394      167743 :       // Every index must be constant.
    1395      165837 :       size_t i, e;
    1396      194460 :       for (i = 0, e = IdxList.size(); i != e; ++i)
    1397     1385890 :         if (!isa<Constant>(IdxList[i]))
    1398     1343921 :           break;
    1399         102 :       if (i == e)
    1400        2828 :         return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
    1401       59356 :     }
    1402      393752 :     return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
    1403      336738 :   }
    1404     2048576 : 
    1405     2055573 :   Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
    1406        6767 :                            const Twine &Name = "") {
    1407         412 :     return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
    1408     1989263 :   }
    1409     1963016 : 
    1410         883 :   Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
    1411       10469 :                            const Twine &Name = "") {
    1412       10210 :     if (auto *PC = dyn_cast<Constant>(Ptr)) {
    1413      106483 :       // Every index must be constant.
    1414      109008 :       size_t i, e;
    1415       22996 :       for (i = 0, e = IdxList.size(); i != e; ++i)
    1416       21162 :         if (!isa<Constant>(IdxList[i]))
    1417         702 :           break;
    1418        1083 :       if (i == e)
    1419         238 :         return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
    1420      163736 :                       Name);
    1421      304525 :     }
    1422      152899 :     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
    1423       13201 :   }
    1424      423363 : 
    1425      422247 :   Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
    1426        1083 :     return CreateGEP(nullptr, Ptr, Idx, Name);
    1427         222 :   }
    1428     2052512 : 
    1429     2072703 :   Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
    1430          39 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1431         784 :       if (auto *IC = dyn_cast<Constant>(Idx))
    1432        1449 :         return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
    1433       40640 :     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
    1434        8220 :   }
    1435     1986214 : 
    1436     2285897 :   Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
    1437      310852 :                            const Twine &Name = "") {
    1438          26 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1439        3858 :       if (auto *IC = dyn_cast<Constant>(Idx))
    1440      530117 :         return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
    1441      544192 :     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
    1442       13940 :   }
    1443          70 : 
    1444        2199 :   Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
    1445        2146 :     return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
    1446        2375 :   }
    1447         931 : 
    1448         202 :   Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
    1449      201913 :                             const Twine &Name = "") {
    1450      204109 :     Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
    1451        2352 : 
    1452        9620 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1453          22 :       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
    1454       15584 : 
    1455       12646 :     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
    1456          64 :   }
    1457        3341 : 
    1458          76 :   Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
    1459         696 :                                     const Twine &Name = "") {
    1460      172389 :     Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
    1461         447 : 
    1462       32017 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1463           5 :       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
    1464         469 : 
    1465      515918 :     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
    1466      663205 :   }
    1467         318 : 
    1468      166482 :   Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
    1469             :                             const Twine &Name = "") {
    1470      173606 :     Value *Idxs[] = {
    1471       13264 :       ConstantInt::get(Type::getInt32Ty(Context), Idx0),
    1472        6511 :       ConstantInt::get(Type::getInt32Ty(Context), Idx1)
    1473       11828 :     };
    1474        6197 : 
    1475         200 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1476       48361 :       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
    1477       18465 : 
    1478        1309 :     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
    1479          75 :   }
    1480          69 : 
    1481       17596 :   Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
    1482       23357 :                                     unsigned Idx1, const Twine &Name = "") {
    1483        3210 :     Value *Idxs[] = {
    1484        9210 :       ConstantInt::get(Type::getInt32Ty(Context), Idx0),
    1485        3258 :       ConstantInt::get(Type::getInt32Ty(Context), Idx1)
    1486        9577 :     };
    1487        3129 : 
    1488       45353 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1489        9921 :       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
    1490        1648 : 
    1491       10801 :     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
    1492           3 :   }
    1493       11466 : 
    1494         175 :   Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
    1495         138 :     Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
    1496         322 : 
    1497        1568 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1498          74 :       return Insert(Folder.CreateGetElementPtr(nullptr, PC, Idx), Name);
    1499          41 : 
    1500           0 :     return Insert(GetElementPtrInst::Create(nullptr, Ptr, Idx), Name);
    1501      156810 :   }
    1502         667 : 
    1503       33836 :   Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
    1504      152381 :                                     const Twine &Name = "") {
    1505       30622 :     Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
    1506         530 : 
    1507         557 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1508           0 :       return Insert(Folder.CreateInBoundsGetElementPtr(nullptr, PC, Idx), Name);
    1509       13489 : 
    1510       84170 :     return Insert(GetElementPtrInst::CreateInBounds(nullptr, Ptr, Idx), Name);
    1511          54 :   }
    1512        5830 : 
    1513       44435 :   Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
    1514        2136 :                     const Twine &Name = "") {
    1515       44169 :     Value *Idxs[] = {
    1516      194863 :       ConstantInt::get(Type::getInt64Ty(Context), Idx0),
    1517       44601 :       ConstantInt::get(Type::getInt64Ty(Context), Idx1)
    1518         220 :     };
    1519             : 
    1520        3007 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1521        5988 :       return Insert(Folder.CreateGetElementPtr(nullptr, PC, Idxs), Name);
    1522         485 : 
    1523       45923 :     return Insert(GetElementPtrInst::Create(nullptr, Ptr, Idxs), Name);
    1524        6683 :   }
    1525        5563 : 
    1526      173325 :   Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
    1527        2808 :                                     const Twine &Name = "") {
    1528      171494 :     Value *Idxs[] = {
    1529      172626 :       ConstantInt::get(Type::getInt64Ty(Context), Idx0),
    1530      171439 :       ConstantInt::get(Type::getInt64Ty(Context), Idx1)
    1531        6959 :     };
    1532         209 : 
    1533          76 :     if (auto *PC = dyn_cast<Constant>(Ptr))
    1534         285 :       return Insert(Folder.CreateInBoundsGetElementPtr(nullptr, PC, Idxs),
    1535          94 :                     Name);
    1536        2048 : 
    1537       44072 :     return Insert(GetElementPtrInst::CreateInBounds(nullptr, Ptr, Idxs), Name);
    1538         308 :   }
    1539       44583 : 
    1540       44380 :   Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
    1541      141682 :                          const Twine &Name = "") {
    1542         644 :     return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
    1543       97559 :   }
    1544       97927 : 
    1545       97580 :   Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") {
    1546        1374 :     return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name);
    1547       37120 :   }
    1548           9 : 
    1549         407 :   /// Same as CreateGlobalString, but return a pointer with "i8*" type
    1550           5 :   /// instead of a pointer to array of i8.
    1551      122225 :   Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
    1552        8776 :                                   unsigned AddressSpace = 0) {
    1553       24759 :     GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
    1554       24734 :     Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
    1555       24793 :     Constant *Indices[] = {Zero, Zero};
    1556     1524852 :     return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
    1557       24776 :                                                   Indices);
    1558     1501273 :   }
    1559     1500203 : 
    1560     1501306 :   //===--------------------------------------------------------------------===//
    1561          63 :   // Instruction creation methods: Cast/Conversion Operators
    1562          59 :   //===--------------------------------------------------------------------===//
    1563          31 : 
    1564          28 :   Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
    1565        4686 :     return CreateCast(Instruction::Trunc, V, DestTy, Name);
    1566      860291 :   }
    1567         672 : 
    1568         676 :   Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
    1569        3247 :     return CreateCast(Instruction::ZExt, V, DestTy, Name);
    1570      410214 :   }
    1571         369 : 
    1572      410294 :   Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
    1573      411312 :     return CreateCast(Instruction::SExt, V, DestTy, Name);
    1574      410286 :   }
    1575         515 : 
    1576          72 :   /// Create a ZExt or Trunc from the integer value V to DestTy. Return
    1577          72 :   /// the value untouched if the type of V is already DestTy.
    1578          48 :   Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
    1579         393 :                            const Twine &Name = "") {
    1580      410144 :     assert(V->getType()->isIntOrIntVectorTy() &&
    1581        2429 :            DestTy->isIntOrIntVectorTy() &&
    1582        5383 :            "Can only zero extend/truncate integers!");
    1583        2489 :     Type *VTy = V->getType();
    1584        2552 :     if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
    1585        2452 :       return CreateZExt(V, DestTy, Name);
    1586          25 :     if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
    1587         427 :       return CreateTrunc(V, DestTy, Name);
    1588        7372 :     return V;
    1589        7623 :   }
    1590          77 : 
    1591         145 :   /// Create a SExt or Trunc from the integer value V to DestTy. Return
    1592         213 :   /// the value untouched if the type of V is already DestTy.
    1593        1450 :   Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
    1594        7682 :                            const Twine &Name = "") {
    1595         151 :     assert(V->getType()->isIntOrIntVectorTy() &&
    1596         184 :            DestTy->isIntOrIntVectorTy() &&
    1597       11391 :            "Can only sign extend/truncate integers!");
    1598        9753 :     Type *VTy = V->getType();
    1599       12218 :     if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
    1600         907 :       return CreateSExt(V, DestTy, Name);
    1601         912 :     if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
    1602       97623 :       return CreateTrunc(V, DestTy, Name);
    1603             :     return V;
    1604       11122 :   }
    1605             : 
    1606           9 :   Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = ""){
    1607         674 :     return CreateCast(Instruction::FPToUI, V, DestTy, Name);
    1608          74 :   }
    1609          27 : 
    1610          27 :   Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = ""){
    1611          87 :     return CreateCast(Instruction::FPToSI, V, DestTy, Name);
    1612         424 :   }
    1613         612 : 
    1614          69 :   Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
    1615         872 :     return CreateCast(Instruction::UIToFP, V, DestTy, Name);
    1616         130 :   }
    1617     1500156 : 
    1618         328 :   Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
    1619         242 :     return CreateCast(Instruction::SIToFP, V, DestTy, Name);
    1620          75 :   }
    1621           6 : 
    1622          34 :   Value *CreateFPTrunc(Value *V, Type *DestTy,
    1623             :                        const Twine &Name = "") {
    1624          60 :     return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
    1625         335 :   }
    1626             : 
    1627         243 :   Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
    1628          78 :     return CreateCast(Instruction::FPExt, V, DestTy, Name);
    1629         945 :   }
    1630         243 : 
    1631      410462 :   Value *CreatePtrToInt(Value *V, Type *DestTy,
    1632         243 :                         const Twine &Name = "") {
    1633         766 :     return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
    1634             :   }
    1635             : 
    1636           0 :   Value *CreateIntToPtr(Value *V, Type *DestTy,
    1637         759 :                         const Twine &Name = "") {
    1638        3932 :     return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
    1639           7 :   }
    1640       46417 : 
    1641          57 :   Value *CreateBitCast(Value *V, Type *DestTy,
    1642           7 :                        const Twine &Name = "") {
    1643      240666 :     return CreateCast(Instruction::BitCast, V, DestTy, Name);
    1644       42634 :   }
    1645           0 : 
    1646             :   Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
    1647          66 :                              const Twine &Name = "") {
    1648          39 :     return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
    1649         455 :   }
    1650         104 : 
    1651         495 :   Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
    1652       15343 :                              const Twine &Name = "") {
    1653         513 :     if (V->getType() == DestTy)
    1654          12 :       return V;
    1655          98 :     if (auto *VC = dyn_cast<Constant>(V))
    1656         223 :       return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
    1657         915 :     return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
    1658        2607 :   }
    1659         197 : 
    1660          12 :   Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
    1661           0 :                              const Twine &Name = "") {
    1662          10 :     if (V->getType() == DestTy)
    1663       27943 :       return V;
    1664         160 :     if (auto *VC = dyn_cast<Constant>(V))
    1665           0 :       return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
    1666           0 :     return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
    1667         502 :   }
    1668        2055 : 
    1669         836 :   Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
    1670             :                               const Twine &Name = "") {
    1671         836 :     if (V->getType() == DestTy)
    1672           8 :       return V;
    1673         522 :     if (auto *VC = dyn_cast<Constant>(V))
    1674          42 :       return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
    1675        1388 :     return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
    1676           0 :   }
    1677         163 : 
    1678      285842 :   Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
    1679         113 :                     const Twine &Name = "") {
    1680      280127 :     if (V->getType() == DestTy)
    1681         201 :       return V;
    1682         111 :     if (auto *VC = dyn_cast<Constant>(V))
    1683      191476 :       return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
    1684      172868 :     return Insert(CastInst::Create(Op, V, DestTy), Name);
    1685             :   }
    1686        1277 : 
    1687       28486 :   Value *CreatePointerCast(Value *V, Type *DestTy,
    1688      132620 :                            const Twine &Name = "") {
    1689       28534 :     if (V->getType() == DestTy)
    1690        2377 :       return V;
    1691         657 :     if (auto *VC = dyn_cast<Constant>(V))
    1692        3217 :       return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
    1693       60722 :     return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
    1694         520 :   }
    1695        3238 : 
    1696          23 :   Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
    1697         850 :                                              const Twine &Name = "") {
    1698      403582 :     if (V->getType() == DestTy)
    1699        4636 :       return V;
    1700          20 : 
    1701        2005 :     if (auto *VC = dyn_cast<Constant>(V)) {
    1702           0 :       return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
    1703       57137 :                     Name);
    1704          86 :     }
    1705        3261 : 
    1706         616 :     return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
    1707      288699 :                   Name);
    1708        1126 :   }
    1709       13697 : 
    1710        1319 :   Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
    1711          20 :                        const Twine &Name = "") {
    1712        1281 :     if (V->getType() == DestTy)
    1713       13138 :       return V;
    1714         851 :     if (auto *VC = dyn_cast<Constant>(V))
    1715         216 :       return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
    1716         840 :     return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
    1717       25974 :   }
    1718      880653 : 
    1719        5779 :   Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
    1720           9 :                                 const Twine &Name = "") {
    1721          91 :     if (V->getType() == DestTy)
    1722        4206 :       return V;
    1723       28386 :     if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
    1724     1544237 :       return CreatePtrToInt(V, DestTy, Name);
    1725        2302 :     if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
    1726           1 :       return CreateIntToPtr(V, DestTy, Name);
    1727       24733 : 
    1728       21704 :     return CreateBitCast(V, DestTy, Name);
    1729        2338 :   }
    1730       21619 : 
    1731           0 :   Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
    1732       71928 :     if (V->getType() == DestTy)
    1733       16816 :       return V;
    1734       16700 :     if (auto *VC = dyn_cast<Constant>(V))
    1735       16015 :       return Insert(Folder.CreateFPCast(VC, DestTy), Name);
    1736         527 :     return Insert(CastInst::CreateFPCast(V, DestTy), Name);
    1737      174270 :   }
    1738       57366 : 
    1739       31326 :   // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
    1740       72849 :   // compile time error, instead of converting the string to bool for the
    1741          15 :   // isSigned parameter.
    1742     2159986 :   Value *CreateIntCast(Value *, Type *, const char *) = delete;
    1743        3127 : 
    1744     2209694 :   //===--------------------------------------------------------------------===//
    1745        2641 :   // Instruction creation methods: Compare Instructions
    1746         500 :   //===--------------------------------------------------------------------===//
    1747       70160 : 
    1748     1107397 :   Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
    1749        5057 :     return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
    1750         259 :   }
    1751         117 : 
    1752       18298 :   Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
    1753       51447 :     return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
    1754       21481 :   }
    1755       49786 : 
    1756      111767 :   Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
    1757        1639 :     return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
    1758      131610 :   }
    1759     1592890 : 
    1760       53641 :   Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
    1761     1544442 :     return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
    1762       38482 :   }
    1763        2214 : 
    1764       14562 :   Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
    1765       79392 :     return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
    1766         480 :   }
    1767        4173 : 
    1768         213 :   Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
    1769       29672 :     return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
    1770         264 :   }
    1771          70 : 
    1772       23145 :   Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
    1773          38 :     return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
    1774       22981 :   }
    1775           0 : 
    1776        2311 :   Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
    1777       11219 :     return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
    1778        2393 :   }
    1779       14337 : 
    1780           8 :   Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
    1781        2485 :     return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
    1782         940 :   }
    1783       26415 : 
    1784         173 :   Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
    1785        1871 :     return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
    1786         334 :   }
    1787         111 : 
    1788        2096 :   Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
    1789          20 :                        MDNode *FPMathTag = nullptr) {
    1790         131 :     return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
    1791      650329 :   }
    1792          94 : 
    1793      650665 :   Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
    1794        6703 :                        MDNode *FPMathTag = nullptr) {
    1795         178 :     return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
    1796      530713 :   }
    1797      110009 : 
    1798          26 :   Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
    1799         245 :                        MDNode *FPMathTag = nullptr) {
    1800         144 :     return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
    1801          72 :   }
    1802          95 : 
    1803           9 :   Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
    1804       13935 :                        MDNode *FPMathTag = nullptr) {
    1805          57 :     return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
    1806       12119 :   }
    1807           0 : 
    1808          74 :   Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
    1809          20 :                        MDNode *FPMathTag = nullptr) {
    1810        8930 :     return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
    1811           8 :   }
    1812          12 : 
    1813         104 :   Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
    1814          12 :                        MDNode *FPMathTag = nullptr) {
    1815          40 :     return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
    1816          24 :   }
    1817         225 : 
    1818           1 :   Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
    1819           2 :                        MDNode *FPMathTag = nullptr) {
    1820         370 :     return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
    1821          26 :   }
    1822           1 : 
    1823        6191 :   Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
    1824         337 :                        MDNode *FPMathTag = nullptr) {
    1825        1159 :     return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
    1826             :   }
    1827             : 
    1828         283 :   Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
    1829       16423 :                        MDNode *FPMathTag = nullptr) {
    1830        1224 :     return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
    1831             :   }
    1832          18 : 
    1833         177 :   Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
    1834        3423 :                        MDNode *FPMathTag = nullptr) {
    1835           4 :     return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
    1836         265 :   }
    1837         949 : 
    1838          26 :   Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
    1839           8 :                        MDNode *FPMathTag = nullptr) {
    1840          28 :     return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
    1841           0 :   }
    1842          19 : 
    1843        1034 :   Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
    1844          44 :                        MDNode *FPMathTag = nullptr) {
    1845         112 :     return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
    1846             :   }
    1847       28057 : 
    1848             :   Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
    1849          84 :                        MDNode *FPMathTag = nullptr) {
    1850          29 :     return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
    1851          20 :   }
    1852           4 : 
    1853             :   Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
    1854          20 :                        MDNode *FPMathTag = nullptr) {
    1855          23 :     return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
    1856             :   }
    1857          32 : 
    1858       14616 :   Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
    1859          12 :                     const Twine &Name = "") {
    1860           1 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1861          25 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1862         590 :         return Insert(Folder.CreateICmp(P, LC, RC), Name);
    1863       28076 :     return Insert(new ICmpInst(P, LHS, RHS), Name);
    1864         857 :   }
    1865         118 : 
    1866         404 :   Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
    1867           0 :                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
    1868         121 :     if (auto *LC = dyn_cast<Constant>(LHS))
    1869        1460 :       if (auto *RC = dyn_cast<Constant>(RHS))
    1870          66 :         return Insert(Folder.CreateFCmp(P, LC, RC), Name);
    1871         754 :     return Insert(setFPAttrs(new FCmpInst(P, LHS, RHS), FPMathTag, FMF), Name);
    1872        1665 :   }
    1873           0 : 
    1874             :   //===--------------------------------------------------------------------===//
    1875         132 :   // Instruction creation methods: Other Instructions
    1876           2 :   //===--------------------------------------------------------------------===//
    1877        3326 : 
    1878        4155 :   PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
    1879         149 :                      const Twine &Name = "") {
    1880        3830 :     return Insert(PHINode::Create(Ty, NumReservedValues), Name);
    1881             :   }
    1882           0 : 
    1883         967 :   CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
    1884        3759 :                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
    1885        5873 :     auto *PTy = cast<PointerType>(Callee->getType());
    1886        8293 :     auto *FTy = cast<FunctionType>(PTy->getElementType());
    1887        4534 :     return CreateCall(FTy, Callee, Args, Name, FPMathTag);
    1888          28 :   }
    1889          10 : 
    1890      102274 :   CallInst *CreateCall(FunctionType *FTy, Value *Callee,
    1891           3 :                        ArrayRef<Value *> Args, const Twine &Name = "",
    1892      114698 :                        MDNode *FPMathTag = nullptr) {
    1893      102354 :     CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
    1894      216970 :     if (isa<FPMathOperator>(CI))
    1895        2435 :       CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
    1896      102593 :     return Insert(CI, Name);
    1897           0 :   }
    1898         424 : 
    1899         664 :   CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
    1900      148088 :                        ArrayRef<OperandBundleDef> OpBundles,
    1901         248 :                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
    1902         996 :     CallInst *CI = CallInst::Create(Callee, Args, OpBundles);
    1903      148627 :     if (isa<FPMathOperator>(CI))
    1904      148424 :       CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
    1905        4275 :     return Insert(CI, Name);
    1906      148137 :   }
    1907         237 : 
    1908         260 :   CallInst *CreateCall(Function *Callee, ArrayRef<Value *> Args,
    1909          73 :                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
    1910       96716 :     return CreateCall(Callee->getFunctionType(), Callee, Args, Name, FPMathTag);
    1911         702 :   }
    1912         599 : 
    1913        8990 :   Value *CreateSelect(Value *C, Value *True, Value *False,
    1914         160 :                       const Twine &Name = "", Instruction *MDFrom = nullptr) {
    1915         679 :     if (auto *CC = dyn_cast<Constant>(C))
    1916         360 :       if (auto *TC = dyn_cast<Constant>(True))
    1917         127 :         if (auto *FC = dyn_cast<Constant>(False))
    1918        2028 :           return Insert(Folder.CreateSelect(CC, TC, FC), Name);
    1919        1292 : 
    1920        8254 :     SelectInst *Sel = SelectInst::Create(C, True, False);
    1921        7885 :     if (MDFrom) {
    1922        1545 :       MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
    1923        5383 :       MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
    1924         148 :       Sel = addBranchMetadata(Sel, Prof, Unpred);
    1925        5546 :     }
    1926        8112 :     return Insert(Sel, Name);
    1927        4210 :   }
    1928         218 : 
    1929         154 :   VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
    1930      103833 :     return Insert(new VAArgInst(List, Ty), Name);
    1931      103610 :   }
    1932      104096 : 
    1933       38891 :   Value *CreateExtractElement(Value *Vec, Value *Idx,
    1934        2513 :                               const Twine &Name = "") {
    1935        4679 :     if (auto *VC = dyn_cast<Constant>(Vec))
    1936         243 :       if (auto *IC = dyn_cast<Constant>(Idx))
    1937         275 :         return Insert(Folder.CreateExtractElement(VC, IC), Name);
    1938       36812 :     return Insert(ExtractElementInst::Create(Vec, Idx), Name);
    1939      316619 :   }
    1940        2645 : 
    1941         179 :   Value *CreateExtractElement(Value *Vec, uint64_t Idx,
    1942         367 :                               const Twine &Name = "") {
    1943        2593 :     return CreateExtractElement(Vec, getInt64(Idx), Name);
    1944      315257 :   }
    1945         489 : 
    1946      198282 :   Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
    1947        3947 :                              const Twine &Name = "") {
    1948         330 :     if (auto *VC = dyn_cast<Constant>(Vec))
    1949         383 :       if (auto *NC = dyn_cast<Constant>(NewElt))
    1950         223 :         if (auto *IC = dyn_cast<Constant>(Idx))
    1951      192314 :           return Insert(Folder.CreateInsertElement(VC, NC, IC), Name);
    1952       36933 :     return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
    1953        2552 :   }
    1954        3780 : 
    1955        2405 :   Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
    1956        3376 :                              const Twine &Name = "") {
    1957       23101 :     return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
    1958         320 :   }
    1959        5172 : 
    1960       11598 :   Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
    1961        4971 :                              const Twine &Name = "") {
    1962        4210 :     if (auto *V1C = dyn_cast<Constant>(V1))
    1963        5216 :       if (auto *V2C = dyn_cast<Constant>(V2))
    1964          30 :         if (auto *MC = dyn_cast<Constant>(Mask))
    1965       16930 :           return Insert(Folder.CreateShuffleVector(V1C, V2C, MC), Name);
    1966       27641 :     return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
    1967       13663 :   }
    1968          90 : 
    1969        7173 :   Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<uint32_t> IntMask,
    1970        1893 :                              const Twine &Name = "") {
    1971        4925 :     Value *Mask = ConstantDataVector::get(Context, IntMask);
    1972        8521 :     return CreateShuffleVector(V1, V2, Mask, Name);
    1973         165 :   }
    1974        8798 : 
    1975        4038 :   Value *CreateExtractValue(Value *Agg,
    1976         828 :                             ArrayRef<unsigned> Idxs,
    1977         142 :                             const Twine &Name = "") {
    1978         219 :     if (auto *AggC = dyn_cast<Constant>(Agg))
    1979        6172 :       return Insert(Folder.CreateExtractValue(AggC, Idxs), Name);
    1980       24954 :     return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
    1981        6369 :   }
    1982         130 : 
    1983         510 :   Value *CreateInsertValue(Value *Agg, Value *Val,
    1984        1204 :                            ArrayRef<unsigned> Idxs,
    1985        2580 :                            const Twine &Name = "") {
    1986         474 :     if (auto *AggC = dyn_cast<Constant>(Agg))
    1987        1741 :       if (auto *ValC = dyn_cast<Constant>(Val))
    1988     2295183 :         return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
    1989        1362 :     return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
    1990         252 :   }
    1991     2295249 : 
    1992     2305419 :   LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
    1993       20691 :                                    const Twine &Name = "") {
    1994     2296960 :     return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
    1995        1715 :   }
    1996        2316 : 
    1997        9374 :   //===--------------------------------------------------------------------===//
    1998        2551 :   // Utility creation methods
    1999          65 :   //===--------------------------------------------------------------------===//
    2000        1716 : 
    2001         106 :   /// Return an i1 value testing if \p Arg is null.
    2002         391 :   Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
    2003         422 :     return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
    2004       19383 :                         Name);
    2005        1138 :   }
    2006       18100 : 
    2007          96 :   /// Return an i1 value testing if \p Arg is not null.
    2008         799 :   Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
    2009         580 :     return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
    2010        1704 :                         Name);
    2011        5872 :   }
    2012        5848 : 
    2013        5941 :   /// Return the i64 difference between two pointer values, dividing out
    2014           2 :   /// the size of the pointed-to objects.
    2015          46 :   ///
    2016           0 :   /// This is intended to implement C-style pointer subtraction. As such, the
    2017          24 :   /// pointers must be appropriately aligned for their element types and
    2018          63 :   /// pointing into the same object.
    2019           0 :   Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
    2020         473 :     assert(LHS->getType() == RHS->getType() &&
    2021         190 :            "Pointer subtraction operand types must match!");
    2022           0 :     auto *ArgType = cast<PointerType>(LHS->getType());
    2023           0 :     Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
    2024          70 :     Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
    2025         138 :     Value *Difference = CreateSub(LHS_int, RHS_int);
    2026         305 :     return CreateExactSDiv(Difference,
    2027        1049 :                            ConstantExpr::getSizeOf(ArgType->getElementType()),
    2028          28 :                            Name);
    2029          53 :   }
    2030          26 : 
    2031          18 :   /// Create a launder.invariant.group intrinsic call. If Ptr type is
    2032         849 :   /// different from pointer to i8, it's casted to pointer to i8 in the same
    2033             :   /// address space before call and casted back to Ptr type after call.
    2034           0 :   Value *CreateLaunderInvariantGroup(Value *Ptr) {
    2035         727 :     assert(isa<PointerType>(Ptr->getType()) &&
    2036       15686 :            "launder.invariant.group only applies to pointers.");
    2037          45 :     // FIXME: we could potentially avoid casts to/from i8*.
    2038          72 :     auto *PtrType = Ptr->getType();
    2039        2993 :     auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
    2040        2015 :     if (PtrType != Int8PtrTy)
    2041           0 :       Ptr = CreateBitCast(Ptr, Int8PtrTy);
    2042             :     Module *M = BB->getParent()->getParent();
    2043        1140 :     Function *FnLaunderInvariantGroup = Intrinsic::getDeclaration(
    2044         860 :         M, Intrinsic::launder_invariant_group, {Int8PtrTy});
    2045        1216 : 
    2046        2228 :     assert(FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
    2047        2045 :            FnLaunderInvariantGroup->getFunctionType()->getParamType(0) ==
    2048         362 :                Int8PtrTy &&
    2049        1992 :            "LaunderInvariantGroup should take and return the same type");
    2050         346 : 
    2051             :     CallInst *Fn = CreateCall(FnLaunderInvariantGroup, {Ptr});
    2052        1979 : 
    2053           6 :     if (PtrType != Int8PtrTy)
    2054         496 :       return CreateBitCast(Fn, PtrType);
    2055           6 :     return Fn;
    2056             :   }
    2057         598 : 
    2058         598 :   /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
    2059        1292 :   /// different from pointer to i8, it's casted to pointer to i8 in the same
    2060           0 :   /// address space before call and casted back to Ptr type after call.
    2061             :   Value *CreateStripInvariantGroup(Value *Ptr) {
    2062             :     assert(isa<PointerType>(Ptr->getType()) &&
    2063       90692 :            "strip.invariant.group only applies to pointers.");
    2064       28596 : 
    2065          14 :     // FIXME: we could potentially avoid casts to/from i8*.
    2066      165939 :     auto *PtrType = Ptr->getType();
    2067          24 :     auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
    2068           0 :     if (PtrType != Int8PtrTy)
    2069      713653 :       Ptr = CreateBitCast(Ptr, Int8PtrTy);
    2070      165906 :     Module *M = BB->getParent()->getParent();
    2071          33 :     Function *FnStripInvariantGroup = Intrinsic::getDeclaration(
    2072      324803 :         M, Intrinsic::strip_invariant_group, {Int8PtrTy});
    2073         554 : 
    2074      906582 :     assert(FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
    2075         176 :            FnStripInvariantGroup->getFunctionType()->getParamType(0) ==
    2076        6188 :                Int8PtrTy &&
    2077       13487 :            "StripInvariantGroup should take and return the same type");
    2078       11987 : 
    2079         122 :     CallInst *Fn = CreateCall(FnStripInvariantGroup, {Ptr});
    2080         122 : 
    2081         122 :     if (PtrType != Int8PtrTy)
    2082           0 :       return CreateBitCast(Fn, PtrType);
    2083         354 :     return Fn;
    2084        4658 :   }
    2085        4658 : 
    2086        9054 :   /// Return a vector value that contains \arg V broadcasted to \p
    2087             :   /// NumElts elements.
    2088        3420 :   Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") {
    2089        3438 :     assert(NumElts > 0 && "Cannot splat to an empty vector!");
    2090        3400 : 
    2091        4105 :     // First insert it into an undef vector so we can shuffle it.
    2092        7737 :     Type *I32Ty = getInt32Ty();
    2093        3857 :     Value *Undef = UndefValue::get(VectorType::get(V->getType(), NumElts));
    2094        3852 :     V = CreateInsertElement(Undef, V, ConstantInt::get(I32Ty, 0),
    2095        6008 :                             Name + ".splatinsert");
    2096        1053 : 
    2097        3086 :     // Shuffle the value across the desired number of elements.
    2098        7072 :     Value *Zeros = ConstantAggregateZero::get(VectorType::get(I32Ty, NumElts));
    2099        4475 :     return CreateShuffleVector(V, Undef, Zeros, Name + ".splat");
    2100        1051 :   }
    2101         879 : 
    2102       27842 :   /// Return a value that has been extracted from a larger integer type.
    2103       28370 :   Value *CreateExtractInteger(const DataLayout &DL, Value *From,
    2104       28360 :                               IntegerType *ExtractedTy, uint64_t Offset,
    2105           0 :                               const Twine &Name) {
    2106         394 :     auto *IntTy = cast<IntegerType>(From->getType());
    2107           0 :     assert(DL.getTypeStoreSize(ExtractedTy) + Offset <=
    2108          43 :                DL.getTypeStoreSize(IntTy) &&
    2109          42 :            "Element extends past full value");
    2110             :     uint64_t ShAmt = 8 * Offset;
    2111           5 :     Value *V = From;
    2112           5 :     if (DL.isBigEndian())
    2113          16 :       ShAmt = 8 * (DL.getTypeStoreSize(IntTy) -
    2114          11 :                    DL.getTypeStoreSize(ExtractedTy) - Offset);
    2115          11 :     if (ShAmt) {
    2116          11 :       V = CreateLShr(V, ShAmt, Name + ".shift");
    2117          16 :     }
    2118          12 :     assert(ExtractedTy->getBitWidth() <= IntTy->getBitWidth() &&
    2119             :            "Cannot extract to a larger integer!");
    2120             :     if (ExtractedTy != IntTy) {
    2121          13 :       V = CreateTrunc(V, ExtractedTy, Name + ".trunc");
    2122             :     }
    2123             :     return V;
    2124             :   }
    2125           5 : 
    2126          19 : private:
    2127          18 :   /// Helper function that creates an assume intrinsic call that
    2128          24 :   /// represents an alignment assumption on the provided Ptr, Mask, Type
    2129           6 :   /// and Offset.
    2130          30 :   CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
    2131          26 :                                             Value *PtrValue, Value *Mask,
    2132           0 :                                             Type *IntPtrTy,
    2133          12 :                                             Value *OffsetValue) {
    2134          25 :     Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
    2135           8 : 
    2136          30 :     if (OffsetValue) {
    2137          12 :       bool IsOffsetZero = false;
    2138          12 :       if (const auto *CI = dyn_cast<ConstantInt>(OffsetValue))
    2139          25 :         IsOffsetZero = CI->isZero();
    2140          12 : 
    2141          18 :       if (!IsOffsetZero) {
    2142           5 :         if (OffsetValue->getType() != IntPtrTy)
    2143          17 :           OffsetValue = CreateIntCast(OffsetValue, IntPtrTy, /*isSigned*/ true,
    2144          17 :                                       "offsetcast");
    2145           5 :         PtrIntValue = CreateSub(PtrIntValue, OffsetValue, "offsetptr");
    2146          10 :       }
    2147           0 :     }
    2148         124 : 
    2149          17 :     Value *Zero = ConstantInt::get(IntPtrTy, 0);
    2150          17 :     Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
    2151          17 :     Value *InvCond = CreateICmpEQ(MaskedPtr, Zero, "maskcond");
    2152         141 :     return CreateAssumption(InvCond);
    2153         124 :   }
    2154         129 : 
    2155         137 : public:
    2156           5 :   /// Create an assume intrinsic call that represents an alignment
    2157           5 :   /// assumption on the provided pointer.
    2158         124 :   ///
    2159         124 :   /// An optional offset can be provided, and if it is provided, the offset
    2160          13 :   /// must be subtracted from the provided pointer to get the pointer with the
    2161          13 :   /// specified alignment.
    2162          30 :   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
    2163          13 :                                       unsigned Alignment,
    2164          13 :                                       Value *OffsetValue = nullptr) {
    2165          26 :     assert(isa<PointerType>(PtrValue->getType()) &&
    2166             :            "trying to create an alignment assumption on a non-pointer?");
    2167          17 :     auto *PtrTy = cast<PointerType>(PtrValue->getType());
    2168          17 :     Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
    2169             : 
    2170          17 :     Value *Mask = ConstantInt::get(IntPtrTy, Alignment > 0 ? Alignment - 1 : 0);
    2171             :     return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
    2172          17 :                                            OffsetValue);
    2173          13 :   }
    2174             : 
    2175          13 :   /// Create an assume intrinsic call that represents an alignment
    2176          13 :   /// assumption on the provided pointer.
    2177             :   ///
    2178             :   /// An optional offset can be provided, and if it is provided, the offset
    2179             :   /// must be subtracted from the provided pointer to get the pointer with the
    2180             :   /// specified alignment.
    2181             :   ///
    2182         828 :   /// This overload handles the condition where the Alignment is dependent
    2183             :   /// on an existing value rather than a static value.
    2184             :   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
    2185             :                                       Value *Alignment,
    2186         828 :                                       Value *OffsetValue = nullptr) {
    2187         828 :     assert(isa<PointerType>(PtrValue->getType()) &&
    2188         828 :            "trying to create an alignment assumption on a non-pointer?");
    2189         828 :     auto *PtrTy = cast<PointerType>(PtrValue->getType());
    2190             :     Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
    2191             : 
    2192         828 :     if (Alignment->getType() != IntPtrTy)
    2193         828 :       Alignment = CreateIntCast(Alignment, IntPtrTy, /*isSigned*/ true,
    2194             :                                 "alignmentcast");
    2195             :     Value *IsPositive =
    2196             :         CreateICmp(CmpInst::ICMP_SGT, Alignment,
    2197             :                    ConstantInt::get(Alignment->getType(), 0), "ispositive");
    2198             :     Value *PositiveMask =
    2199             :         CreateSub(Alignment, ConstantInt::get(IntPtrTy, 1), "positivemask");
    2200             :     Value *Mask = CreateSelect(IsPositive, PositiveMask,
    2201             :                                ConstantInt::get(IntPtrTy, 0), "mask");
    2202             : 
    2203             :     return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
    2204             :                                            OffsetValue);
    2205             :   }
    2206             : };
    2207             : 
    2208             : // Create wrappers for C Binding types (see CBindingWrapping.h).
    2209             : DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
    2210             : 
    2211         294 : } // end namespace llvm
    2212             : 
    2213             : #endif // LLVM_IR_IRBUILDER_H

Generated by: LCOV version 1.13