1b75c60631b02d0fff231fedd727eb908fb2123d
[oota-llvm.git] / include / llvm / IR / IRBuilder.h
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/ADT/ArrayRef.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/IR/BasicBlock.h"
22 #include "llvm/IR/ConstantFolder.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/Function.h"
25 #include "llvm/IR/GlobalVariable.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/Intrinsics.h"
28 #include "llvm/IR/LLVMContext.h"
29 #include "llvm/IR/Operator.h"
30 #include "llvm/IR/ValueHandle.h"
31 #include "llvm/Support/CBindingWrapping.h"
32
33 namespace llvm {
34 class MDNode;
35
36 /// \brief This provides the default implementation of the IRBuilder
37 /// 'InsertHelper' method that is called whenever an instruction is created by
38 /// IRBuilder and needs to be inserted.
39 ///
40 /// By default, this inserts the instruction at the insertion point.
41 template <bool preserveNames = true>
42 class IRBuilderDefaultInserter {
43 protected:
44   void InsertHelper(Instruction *I, const Twine &Name,
45                     BasicBlock *BB, BasicBlock::iterator InsertPt) const {
46     if (BB) BB->getInstList().insert(InsertPt, I);
47     if (preserveNames)
48       I->setName(Name);
49   }
50 };
51
52 /// \brief Common base class shared among various IRBuilders.
53 class IRBuilderBase {
54   DebugLoc CurDbgLocation;
55
56 protected:
57   BasicBlock *BB;
58   BasicBlock::iterator InsertPt;
59   LLVMContext &Context;
60
61   MDNode *DefaultFPMathTag;
62   FastMathFlags FMF;
63
64   ArrayRef<OperandBundleDef> DefaultOperandBundles;
65
66 public:
67   IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
68                 ArrayRef<OperandBundleDef> OpBundles = None)
69       : Context(context), DefaultFPMathTag(FPMathTag), FMF(),
70         DefaultOperandBundles(OpBundles) {
71     ClearInsertionPoint();
72   }
73
74   //===--------------------------------------------------------------------===//
75   // Builder configuration methods
76   //===--------------------------------------------------------------------===//
77
78   /// \brief Clear the insertion point: created instructions will not be
79   /// inserted into a block.
80   void ClearInsertionPoint() {
81     BB = nullptr;
82     InsertPt.reset(nullptr);
83   }
84
85   BasicBlock *GetInsertBlock() const { return BB; }
86   BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
87   LLVMContext &getContext() const { return Context; }
88
89   /// \brief This specifies that created instructions should be appended to the
90   /// end of the specified block.
91   void SetInsertPoint(BasicBlock *TheBB) {
92     BB = TheBB;
93     InsertPt = BB->end();
94   }
95
96   /// \brief This specifies that created instructions should be inserted before
97   /// the specified instruction.
98   void SetInsertPoint(Instruction *I) {
99     BB = I->getParent();
100     InsertPt = I->getIterator();
101     assert(InsertPt != BB->end() && "Can't read debug loc from end()");
102     SetCurrentDebugLocation(I->getDebugLoc());
103   }
104
105   /// \brief This specifies that created instructions should be inserted at the
106   /// specified point.
107   void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
108     BB = TheBB;
109     InsertPt = IP;
110     if (IP != TheBB->end())
111       SetCurrentDebugLocation(IP->getDebugLoc());
112   }
113
114   /// \brief Set location information used by debugging information.
115   void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); }
116
117   /// \brief Get location information used by debugging information.
118   const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
119
120   /// \brief If this builder has a current debug location, set it on the
121   /// specified instruction.
122   void SetInstDebugLocation(Instruction *I) const {
123     if (CurDbgLocation)
124       I->setDebugLoc(CurDbgLocation);
125   }
126
127   /// \brief Get the return type of the current function that we're emitting
128   /// into.
129   Type *getCurrentFunctionReturnType() const;
130
131   /// InsertPoint - A saved insertion point.
132   class InsertPoint {
133     BasicBlock *Block;
134     BasicBlock::iterator Point;
135
136   public:
137     /// \brief Creates a new insertion point which doesn't point to anything.
138     InsertPoint() : Block(nullptr) {}
139
140     /// \brief Creates a new insertion point at the given location.
141     InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
142       : Block(InsertBlock), Point(InsertPoint) {}
143
144     /// \brief Returns true if this insert point is set.
145     bool isSet() const { return (Block != nullptr); }
146
147     llvm::BasicBlock *getBlock() const { return Block; }
148     llvm::BasicBlock::iterator getPoint() const { return Point; }
149   };
150
151   /// \brief Returns the current insert point.
152   InsertPoint saveIP() const {
153     return InsertPoint(GetInsertBlock(), GetInsertPoint());
154   }
155
156   /// \brief Returns the current insert point, clearing it in the process.
157   InsertPoint saveAndClearIP() {
158     InsertPoint IP(GetInsertBlock(), GetInsertPoint());
159     ClearInsertionPoint();
160     return IP;
161   }
162
163   /// \brief Sets the current insert point to a previously-saved location.
164   void restoreIP(InsertPoint IP) {
165     if (IP.isSet())
166       SetInsertPoint(IP.getBlock(), IP.getPoint());
167     else
168       ClearInsertionPoint();
169   }
170
171   /// \brief Get the floating point math metadata being used.
172   MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
173
174   /// \brief Get the flags to be applied to created floating point ops
175   FastMathFlags getFastMathFlags() const { return FMF; }
176
177   /// \brief Clear the fast-math flags.
178   void clearFastMathFlags() { FMF.clear(); }
179
180   /// \brief Set the floating point math metadata to be used.
181   void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
182
183   /// \brief Set the fast-math flags to be used with generated fp-math operators
184   void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }
185
186   //===--------------------------------------------------------------------===//
187   // RAII helpers.
188   //===--------------------------------------------------------------------===//
189
190   // \brief RAII object that stores the current insertion point and restores it
191   // when the object is destroyed. This includes the debug location.
192   class InsertPointGuard {
193     IRBuilderBase &Builder;
194     AssertingVH<BasicBlock> Block;
195     BasicBlock::iterator Point;
196     DebugLoc DbgLoc;
197
198     InsertPointGuard(const InsertPointGuard &) = delete;
199     InsertPointGuard &operator=(const InsertPointGuard &) = delete;
200
201   public:
202     InsertPointGuard(IRBuilderBase &B)
203         : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
204           DbgLoc(B.getCurrentDebugLocation()) {}
205
206     ~InsertPointGuard() {
207       Builder.restoreIP(InsertPoint(Block, Point));
208       Builder.SetCurrentDebugLocation(DbgLoc);
209     }
210   };
211
212   // \brief RAII object that stores the current fast math settings and restores
213   // them when the object is destroyed.
214   class FastMathFlagGuard {
215     IRBuilderBase &Builder;
216     FastMathFlags FMF;
217     MDNode *FPMathTag;
218
219     FastMathFlagGuard(const FastMathFlagGuard &) = delete;
220     FastMathFlagGuard &operator=(
221         const FastMathFlagGuard &) = delete;
222
223   public:
224     FastMathFlagGuard(IRBuilderBase &B)
225         : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag) {}
226
227     ~FastMathFlagGuard() {
228       Builder.FMF = FMF;
229       Builder.DefaultFPMathTag = FPMathTag;
230     }
231   };
232
233   //===--------------------------------------------------------------------===//
234   // Miscellaneous creation methods.
235   //===--------------------------------------------------------------------===//
236
237   /// \brief Make a new global variable with initializer type i8*
238   ///
239   /// Make a new global variable with an initializer that has array of i8 type
240   /// filled in with the null terminated string value specified.  The new global
241   /// variable will be marked mergable with any others of the same contents.  If
242   /// Name is specified, it is the name of the global variable created.
243   GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
244                                      unsigned AddressSpace = 0);
245
246   /// \brief Get a constant value representing either true or false.
247   ConstantInt *getInt1(bool V) {
248     return ConstantInt::get(getInt1Ty(), V);
249   }
250
251   /// \brief Get the constant value for i1 true.
252   ConstantInt *getTrue() {
253     return ConstantInt::getTrue(Context);
254   }
255
256   /// \brief Get the constant value for i1 false.
257   ConstantInt *getFalse() {
258     return ConstantInt::getFalse(Context);
259   }
260
261   /// \brief Get a constant 8-bit value.
262   ConstantInt *getInt8(uint8_t C) {
263     return ConstantInt::get(getInt8Ty(), C);
264   }
265
266   /// \brief Get a constant 16-bit value.
267   ConstantInt *getInt16(uint16_t C) {
268     return ConstantInt::get(getInt16Ty(), C);
269   }
270
271   /// \brief Get a constant 32-bit value.
272   ConstantInt *getInt32(uint32_t C) {
273     return ConstantInt::get(getInt32Ty(), C);
274   }
275
276   /// \brief Get a constant 64-bit value.
277   ConstantInt *getInt64(uint64_t C) {
278     return ConstantInt::get(getInt64Ty(), C);
279   }
280
281   /// \brief Get a constant N-bit value, zero extended or truncated from
282   /// a 64-bit value.
283   ConstantInt *getIntN(unsigned N, uint64_t C) {
284     return ConstantInt::get(getIntNTy(N), C);
285   }
286
287   /// \brief Get a constant integer value.
288   ConstantInt *getInt(const APInt &AI) {
289     return ConstantInt::get(Context, AI);
290   }
291
292   //===--------------------------------------------------------------------===//
293   // Type creation methods
294   //===--------------------------------------------------------------------===//
295
296   /// \brief Fetch the type representing a single bit
297   IntegerType *getInt1Ty() {
298     return Type::getInt1Ty(Context);
299   }
300
301   /// \brief Fetch the type representing an 8-bit integer.
302   IntegerType *getInt8Ty() {
303     return Type::getInt8Ty(Context);
304   }
305
306   /// \brief Fetch the type representing a 16-bit integer.
307   IntegerType *getInt16Ty() {
308     return Type::getInt16Ty(Context);
309   }
310
311   /// \brief Fetch the type representing a 32-bit integer.
312   IntegerType *getInt32Ty() {
313     return Type::getInt32Ty(Context);
314   }
315
316   /// \brief Fetch the type representing a 64-bit integer.
317   IntegerType *getInt64Ty() {
318     return Type::getInt64Ty(Context);
319   }
320
321   /// \brief Fetch the type representing a 128-bit integer.
322   IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
323
324   /// \brief Fetch the type representing an N-bit integer.
325   IntegerType *getIntNTy(unsigned N) {
326     return Type::getIntNTy(Context, N);
327   }
328
329   /// \brief Fetch the type representing a 16-bit floating point value.
330   Type *getHalfTy() {
331     return Type::getHalfTy(Context);
332   }
333
334   /// \brief Fetch the type representing a 32-bit floating point value.
335   Type *getFloatTy() {
336     return Type::getFloatTy(Context);
337   }
338
339   /// \brief Fetch the type representing a 64-bit floating point value.
340   Type *getDoubleTy() {
341     return Type::getDoubleTy(Context);
342   }
343
344   /// \brief Fetch the type representing void.
345   Type *getVoidTy() {
346     return Type::getVoidTy(Context);
347   }
348
349   /// \brief Fetch the type representing a pointer to an 8-bit integer value.
350   PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
351     return Type::getInt8PtrTy(Context, AddrSpace);
352   }
353
354   /// \brief Fetch the type representing a pointer to an integer value.
355   IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
356     return DL.getIntPtrType(Context, AddrSpace);
357   }
358
359   //===--------------------------------------------------------------------===//
360   // Intrinsic creation methods
361   //===--------------------------------------------------------------------===//
362
363   /// \brief Create and insert a memset to the specified pointer and the
364   /// specified value.
365   ///
366   /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
367   /// specified, it will be added to the instruction. Likewise with alias.scope
368   /// and noalias tags.
369   CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align,
370                          bool isVolatile = false, MDNode *TBAATag = nullptr,
371                          MDNode *ScopeTag = nullptr,
372                          MDNode *NoAliasTag = nullptr) {
373     return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
374                         TBAATag, ScopeTag, NoAliasTag);
375   }
376
377   CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
378                          bool isVolatile = false, MDNode *TBAATag = nullptr,
379                          MDNode *ScopeTag = nullptr,
380                          MDNode *NoAliasTag = nullptr);
381
382   /// \brief Create and insert a memcpy between the specified pointers.
383   ///
384   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
385   /// specified, it will be added to the instruction. Likewise with alias.scope
386   /// and noalias tags.
387   CallInst *CreateMemCpy(Value *Dst, Value *Src, uint64_t Size, unsigned Align,
388                          bool isVolatile = false, MDNode *TBAATag = nullptr,
389                          MDNode *TBAAStructTag = nullptr,
390                          MDNode *ScopeTag = nullptr,
391                          MDNode *NoAliasTag = nullptr) {
392     return CreateMemCpy(Dst, Src, getInt64(Size), Align, isVolatile, TBAATag,
393                         TBAAStructTag, ScopeTag, NoAliasTag);
394   }
395
396   CallInst *CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align,
397                          bool isVolatile = false, MDNode *TBAATag = nullptr,
398                          MDNode *TBAAStructTag = nullptr,
399                          MDNode *ScopeTag = nullptr,
400                          MDNode *NoAliasTag = nullptr);
401
402   /// \brief Create and insert a memmove between the specified
403   /// pointers.
404   ///
405   /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
406   /// specified, it will be added to the instruction. Likewise with alias.scope
407   /// and noalias tags.
408   CallInst *CreateMemMove(Value *Dst, Value *Src, uint64_t Size, unsigned Align,
409                           bool isVolatile = false, MDNode *TBAATag = nullptr,
410                           MDNode *ScopeTag = nullptr,
411                           MDNode *NoAliasTag = nullptr) {
412     return CreateMemMove(Dst, Src, getInt64(Size), Align, isVolatile,
413                          TBAATag, ScopeTag, NoAliasTag);
414   }
415
416   CallInst *CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align,
417                           bool isVolatile = false, MDNode *TBAATag = nullptr,
418                           MDNode *ScopeTag = nullptr,
419                           MDNode *NoAliasTag = nullptr);
420
421   /// \brief Create a lifetime.start intrinsic.
422   ///
423   /// If the pointer isn't i8* it will be converted.
424   CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
425
426   /// \brief Create a lifetime.end intrinsic.
427   ///
428   /// If the pointer isn't i8* it will be converted.
429   CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
430
431   /// \brief Create a call to Masked Load intrinsic
432   CallInst *CreateMaskedLoad(Value *Ptr, unsigned Align, Value *Mask,
433                              Value *PassThru = nullptr, const Twine &Name = "");
434
435   /// \brief Create a call to Masked Store intrinsic
436   CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align,
437                               Value *Mask);
438
439   /// \brief Create an assume intrinsic call that allows the optimizer to
440   /// assume that the provided condition will be true.
441   CallInst *CreateAssumption(Value *Cond);
442
443   /// \brief Create a call to the experimental.gc.statepoint intrinsic to
444   /// start a new statepoint sequence.
445   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
446                                    Value *ActualCallee,
447                                    ArrayRef<Value *> CallArgs,
448                                    ArrayRef<Value *> DeoptArgs,
449                                    ArrayRef<Value *> GCArgs,
450                                    const Twine &Name = "");
451
452   /// \brief Create a call to the experimental.gc.statepoint intrinsic to
453   /// start a new statepoint sequence.
454   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
455                                    Value *ActualCallee, uint32_t Flags,
456                                    ArrayRef<Use> CallArgs,
457                                    ArrayRef<Use> TransitionArgs,
458                                    ArrayRef<Use> DeoptArgs,
459                                    ArrayRef<Value *> GCArgs,
460                                    const Twine &Name = "");
461
462   // \brief Conveninence function for the common case when CallArgs are filled
463   // in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
464   // .get()'ed to get the Value pointer.
465   CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
466                                    Value *ActualCallee, ArrayRef<Use> CallArgs,
467                                    ArrayRef<Value *> DeoptArgs,
468                                    ArrayRef<Value *> GCArgs,
469                                    const Twine &Name = "");
470
471   /// brief Create an invoke to the experimental.gc.statepoint intrinsic to
472   /// start a new statepoint sequence.
473   InvokeInst *
474   CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
475                            Value *ActualInvokee, BasicBlock *NormalDest,
476                            BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
477                            ArrayRef<Value *> DeoptArgs,
478                            ArrayRef<Value *> GCArgs, const Twine &Name = "");
479
480   /// brief Create an invoke to the experimental.gc.statepoint intrinsic to
481   /// start a new statepoint sequence.
482   InvokeInst *CreateGCStatepointInvoke(
483       uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
484       BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
485       ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
486       ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs,
487       const Twine &Name = "");
488
489   // Conveninence function for the common case when CallArgs are filled in using
490   // makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
491   // get the Value *.
492   InvokeInst *
493   CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
494                            Value *ActualInvokee, BasicBlock *NormalDest,
495                            BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
496                            ArrayRef<Value *> DeoptArgs,
497                            ArrayRef<Value *> GCArgs, const Twine &Name = "");
498
499   /// \brief Create a call to the experimental.gc.result intrinsic to extract
500   /// the result from a call wrapped in a statepoint.
501   CallInst *CreateGCResult(Instruction *Statepoint,
502                            Type *ResultType,
503                            const Twine &Name = "");
504
505   /// \brief Create a call to the experimental.gc.relocate intrinsics to
506   /// project the relocated value of one pointer from the statepoint.
507   CallInst *CreateGCRelocate(Instruction *Statepoint,
508                              int BaseOffset,
509                              int DerivedOffset,
510                              Type *ResultType,
511                              const Twine &Name = "");
512
513 private:
514   /// \brief Create a call to a masked intrinsic with given Id.
515   /// Masked intrinsic has only one overloaded type - data type.
516   CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
517                                   Type *DataTy, const Twine &Name = "");
518
519   Value *getCastedInt8PtrValue(Value *Ptr);
520 };
521
522 /// \brief This provides a uniform API for creating instructions and inserting
523 /// them into a basic block: either at the end of a BasicBlock, or at a specific
524 /// iterator location in a block.
525 ///
526 /// Note that the builder does not expose the full generality of LLVM
527 /// instructions.  For access to extra instruction properties, use the mutators
528 /// (e.g. setVolatile) on the instructions after they have been
529 /// created. Convenience state exists to specify fast-math flags and fp-math
530 /// tags.
531 ///
532 /// The first template argument handles whether or not to preserve names in the
533 /// final instruction output. This defaults to on.  The second template argument
534 /// specifies a class to use for creating constants.  This defaults to creating
535 /// minimally folded constants.  The third template argument allows clients to
536 /// specify custom insertion hooks that are called on every newly created
537 /// insertion.
538 template<bool preserveNames = true, typename T = ConstantFolder,
539          typename Inserter = IRBuilderDefaultInserter<preserveNames> >
540 class IRBuilder : public IRBuilderBase, public Inserter {
541   T Folder;
542
543 public:
544   IRBuilder(LLVMContext &C, const T &F, Inserter I = Inserter(),
545             MDNode *FPMathTag = nullptr,
546             ArrayRef<OperandBundleDef> OpBundles = None)
547       : IRBuilderBase(C, FPMathTag, OpBundles), Inserter(std::move(I)),
548         Folder(F) {}
549
550   explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
551                      ArrayRef<OperandBundleDef> OpBundles = None)
552       : IRBuilderBase(C, FPMathTag, OpBundles), Folder() {}
553
554   explicit IRBuilder(BasicBlock *TheBB, const T &F, MDNode *FPMathTag = nullptr,
555                      ArrayRef<OperandBundleDef> OpBundles = None)
556       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
557     SetInsertPoint(TheBB);
558   }
559
560   explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
561                      ArrayRef<OperandBundleDef> OpBundles = None)
562       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder() {
563     SetInsertPoint(TheBB);
564   }
565
566   explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
567                      ArrayRef<OperandBundleDef> OpBundles = None)
568       : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles), Folder() {
569     SetInsertPoint(IP);
570   }
571
572   IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T &F,
573             MDNode *FPMathTag = nullptr,
574             ArrayRef<OperandBundleDef> OpBundles = None)
575       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
576     SetInsertPoint(TheBB, IP);
577   }
578
579   IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
580             MDNode *FPMathTag = nullptr,
581             ArrayRef<OperandBundleDef> OpBundles = None)
582       : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder() {
583     SetInsertPoint(TheBB, IP);
584   }
585
586   /// \brief Get the constant folder being used.
587   const T &getFolder() { return Folder; }
588
589   /// \brief Return true if this builder is configured to actually add the
590   /// requested names to IR created through it.
591   bool isNamePreserving() const { return preserveNames; }
592
593   /// \brief Insert and return the specified instruction.
594   template<typename InstTy>
595   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
596     this->InsertHelper(I, Name, BB, InsertPt);
597     this->SetInstDebugLocation(I);
598     return I;
599   }
600
601   /// \brief No-op overload to handle constants.
602   Constant *Insert(Constant *C, const Twine& = "") const {
603     return C;
604   }
605
606   //===--------------------------------------------------------------------===//
607   // Instruction creation methods: Terminators
608   //===--------------------------------------------------------------------===//
609
610 private:
611   /// \brief Helper to add branch weight and unpredictable metadata onto an
612   /// instruction.
613   /// \returns The annotated instruction.
614   template <typename InstTy>
615   InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
616     if (Weights)
617       I->setMetadata(LLVMContext::MD_prof, Weights);
618     if (Unpredictable)
619       I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
620     return I;
621   }
622
623 public:
624   /// \brief Create a 'ret void' instruction.
625   ReturnInst *CreateRetVoid() {
626     return Insert(ReturnInst::Create(Context));
627   }
628
629   /// \brief Create a 'ret <val>' instruction.
630   ReturnInst *CreateRet(Value *V) {
631     return Insert(ReturnInst::Create(Context, V));
632   }
633
634   /// \brief Create a sequence of N insertvalue instructions,
635   /// with one Value from the retVals array each, that build a aggregate
636   /// return value one value at a time, and a ret instruction to return
637   /// the resulting aggregate value.
638   ///
639   /// This is a convenience function for code that uses aggregate return values
640   /// as a vehicle for having multiple return values.
641   ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
642     Value *V = UndefValue::get(getCurrentFunctionReturnType());
643     for (unsigned i = 0; i != N; ++i)
644       V = CreateInsertValue(V, retVals[i], i, "mrv");
645     return Insert(ReturnInst::Create(Context, V));
646   }
647
648   /// \brief Create an unconditional 'br label X' instruction.
649   BranchInst *CreateBr(BasicBlock *Dest) {
650     return Insert(BranchInst::Create(Dest));
651   }
652
653   /// \brief Create a conditional 'br Cond, TrueDest, FalseDest'
654   /// instruction.
655   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
656                            MDNode *BranchWeights = nullptr,
657                            MDNode *Unpredictable = nullptr) {
658     return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
659                                     BranchWeights, Unpredictable));
660   }
661
662   /// \brief Create a switch instruction with the specified value, default dest,
663   /// and with a hint for the number of cases that will be added (for efficient
664   /// allocation).
665   SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
666                            MDNode *BranchWeights = nullptr,
667                            MDNode *Unpredictable = nullptr) {
668     return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
669                                     BranchWeights, Unpredictable));
670   }
671
672   /// \brief Create an indirect branch instruction with the specified address
673   /// operand, with an optional hint for the number of destinations that will be
674   /// added (for efficient allocation).
675   IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
676     return Insert(IndirectBrInst::Create(Addr, NumDests));
677   }
678
679   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
680                            BasicBlock *UnwindDest, const Twine &Name = "") {
681     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, None),
682                   Name);
683   }
684   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
685                            BasicBlock *UnwindDest, Value *Arg1,
686                            const Twine &Name = "") {
687     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Arg1),
688                   Name);
689   }
690   InvokeInst *CreateInvoke3(Value *Callee, BasicBlock *NormalDest,
691                             BasicBlock *UnwindDest, Value *Arg1,
692                             Value *Arg2, Value *Arg3,
693                             const Twine &Name = "") {
694     Value *Args[] = { Arg1, Arg2, Arg3 };
695     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args),
696                   Name);
697   }
698   /// \brief Create an invoke instruction.
699   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
700                            BasicBlock *UnwindDest, ArrayRef<Value *> Args,
701                            const Twine &Name = "") {
702     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args),
703                   Name);
704   }
705   InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
706                            BasicBlock *UnwindDest, ArrayRef<Value *> Args,
707                            ArrayRef<OperandBundleDef> OpBundles,
708                            const Twine &Name = "") {
709     return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args,
710                                      OpBundles), Name);
711   }
712
713   ResumeInst *CreateResume(Value *Exn) {
714     return Insert(ResumeInst::Create(Exn));
715   }
716
717   CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
718                                       BasicBlock *UnwindBB = nullptr) {
719     return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
720   }
721
722   CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
723                                      unsigned NumHandlers,
724                                      const Twine &Name = "") {
725     return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
726                   Name);
727   }
728
729   CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
730                                const Twine &Name = "") {
731     return Insert(CatchPadInst::Create(ParentPad, Args), Name);
732   }
733
734   CleanupPadInst *CreateCleanupPad(Value *ParentPad,
735                                    ArrayRef<Value *> Args = None,
736                                    const Twine &Name = "") {
737     return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
738   }
739
740   CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
741     return Insert(CatchReturnInst::Create(CatchPad, BB));
742   }
743
744   UnreachableInst *CreateUnreachable() {
745     return Insert(new UnreachableInst(Context));
746   }
747
748   //===--------------------------------------------------------------------===//
749   // Instruction creation methods: Binary Operators
750   //===--------------------------------------------------------------------===//
751 private:
752   BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
753                                           Value *LHS, Value *RHS,
754                                           const Twine &Name,
755                                           bool HasNUW, bool HasNSW) {
756     BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
757     if (HasNUW) BO->setHasNoUnsignedWrap();
758     if (HasNSW) BO->setHasNoSignedWrap();
759     return BO;
760   }
761
762   Instruction *AddFPMathAttributes(Instruction *I,
763                                    MDNode *FPMathTag,
764                                    FastMathFlags FMF) const {
765     if (!FPMathTag)
766       FPMathTag = DefaultFPMathTag;
767     if (FPMathTag)
768       I->setMetadata(LLVMContext::MD_fpmath, FPMathTag);
769     I->setFastMathFlags(FMF);
770     return I;
771   }
772
773 public:
774   Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
775                    bool HasNUW = false, bool HasNSW = false) {
776     if (Constant *LC = dyn_cast<Constant>(LHS))
777       if (Constant *RC = dyn_cast<Constant>(RHS))
778         return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
779     return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
780                                    HasNUW, HasNSW);
781   }
782   Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
783     return CreateAdd(LHS, RHS, Name, false, true);
784   }
785   Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
786     return CreateAdd(LHS, RHS, Name, true, false);
787   }
788   Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = "",
789                     MDNode *FPMathTag = nullptr) {
790     if (Constant *LC = dyn_cast<Constant>(LHS))
791       if (Constant *RC = dyn_cast<Constant>(RHS))
792         return Insert(Folder.CreateFAdd(LC, RC), Name);
793     return Insert(AddFPMathAttributes(BinaryOperator::CreateFAdd(LHS, RHS),
794                                       FPMathTag, FMF), Name);
795   }
796   Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
797                    bool HasNUW = false, bool HasNSW = false) {
798     if (Constant *LC = dyn_cast<Constant>(LHS))
799       if (Constant *RC = dyn_cast<Constant>(RHS))
800         return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
801     return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
802                                    HasNUW, HasNSW);
803   }
804   Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
805     return CreateSub(LHS, RHS, Name, false, true);
806   }
807   Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
808     return CreateSub(LHS, RHS, Name, true, false);
809   }
810   Value *CreateFSub(Value *LHS, Value *RHS, const Twine &Name = "",
811                     MDNode *FPMathTag = nullptr) {
812     if (Constant *LC = dyn_cast<Constant>(LHS))
813       if (Constant *RC = dyn_cast<Constant>(RHS))
814         return Insert(Folder.CreateFSub(LC, RC), Name);
815     return Insert(AddFPMathAttributes(BinaryOperator::CreateFSub(LHS, RHS),
816                                       FPMathTag, FMF), Name);
817   }
818   Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
819                    bool HasNUW = false, bool HasNSW = false) {
820     if (Constant *LC = dyn_cast<Constant>(LHS))
821       if (Constant *RC = dyn_cast<Constant>(RHS))
822         return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
823     return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
824                                    HasNUW, HasNSW);
825   }
826   Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
827     return CreateMul(LHS, RHS, Name, false, true);
828   }
829   Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
830     return CreateMul(LHS, RHS, Name, true, false);
831   }
832   Value *CreateFMul(Value *LHS, Value *RHS, const Twine &Name = "",
833                     MDNode *FPMathTag = nullptr) {
834     if (Constant *LC = dyn_cast<Constant>(LHS))
835       if (Constant *RC = dyn_cast<Constant>(RHS))
836         return Insert(Folder.CreateFMul(LC, RC), Name);
837     return Insert(AddFPMathAttributes(BinaryOperator::CreateFMul(LHS, RHS),
838                                       FPMathTag, FMF), Name);
839   }
840   Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
841                     bool isExact = false) {
842     if (Constant *LC = dyn_cast<Constant>(LHS))
843       if (Constant *RC = dyn_cast<Constant>(RHS))
844         return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
845     if (!isExact)
846       return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
847     return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
848   }
849   Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
850     return CreateUDiv(LHS, RHS, Name, true);
851   }
852   Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
853                     bool isExact = false) {
854     if (Constant *LC = dyn_cast<Constant>(LHS))
855       if (Constant *RC = dyn_cast<Constant>(RHS))
856         return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
857     if (!isExact)
858       return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
859     return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
860   }
861   Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
862     return CreateSDiv(LHS, RHS, Name, true);
863   }
864   Value *CreateFDiv(Value *LHS, Value *RHS, const Twine &Name = "",
865                     MDNode *FPMathTag = nullptr) {
866     if (Constant *LC = dyn_cast<Constant>(LHS))
867       if (Constant *RC = dyn_cast<Constant>(RHS))
868         return Insert(Folder.CreateFDiv(LC, RC), Name);
869     return Insert(AddFPMathAttributes(BinaryOperator::CreateFDiv(LHS, RHS),
870                                       FPMathTag, FMF), Name);
871   }
872   Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
873     if (Constant *LC = dyn_cast<Constant>(LHS))
874       if (Constant *RC = dyn_cast<Constant>(RHS))
875         return Insert(Folder.CreateURem(LC, RC), Name);
876     return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
877   }
878   Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
879     if (Constant *LC = dyn_cast<Constant>(LHS))
880       if (Constant *RC = dyn_cast<Constant>(RHS))
881         return Insert(Folder.CreateSRem(LC, RC), Name);
882     return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
883   }
884   Value *CreateFRem(Value *LHS, Value *RHS, const Twine &Name = "",
885                     MDNode *FPMathTag = nullptr) {
886     if (Constant *LC = dyn_cast<Constant>(LHS))
887       if (Constant *RC = dyn_cast<Constant>(RHS))
888         return Insert(Folder.CreateFRem(LC, RC), Name);
889     return Insert(AddFPMathAttributes(BinaryOperator::CreateFRem(LHS, RHS),
890                                       FPMathTag, FMF), Name);
891   }
892
893   Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
894                    bool HasNUW = false, bool HasNSW = false) {
895     if (Constant *LC = dyn_cast<Constant>(LHS))
896       if (Constant *RC = dyn_cast<Constant>(RHS))
897         return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
898     return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
899                                    HasNUW, HasNSW);
900   }
901   Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
902                    bool HasNUW = false, bool HasNSW = false) {
903     return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
904                      HasNUW, HasNSW);
905   }
906   Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
907                    bool HasNUW = false, bool HasNSW = false) {
908     return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
909                      HasNUW, HasNSW);
910   }
911
912   Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
913                     bool isExact = false) {
914     if (Constant *LC = dyn_cast<Constant>(LHS))
915       if (Constant *RC = dyn_cast<Constant>(RHS))
916         return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
917     if (!isExact)
918       return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
919     return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
920   }
921   Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
922                     bool isExact = false) {
923     return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
924   }
925   Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
926                     bool isExact = false) {
927     return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
928   }
929
930   Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
931                     bool isExact = false) {
932     if (Constant *LC = dyn_cast<Constant>(LHS))
933       if (Constant *RC = dyn_cast<Constant>(RHS))
934         return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
935     if (!isExact)
936       return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
937     return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
938   }
939   Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
940                     bool isExact = false) {
941     return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
942   }
943   Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
944                     bool isExact = false) {
945     return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
946   }
947
948   Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
949     if (Constant *RC = dyn_cast<Constant>(RHS)) {
950       if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isAllOnesValue())
951         return LHS;  // LHS & -1 -> LHS
952       if (Constant *LC = dyn_cast<Constant>(LHS))
953         return Insert(Folder.CreateAnd(LC, RC), Name);
954     }
955     return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
956   }
957   Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
958     return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
959   }
960   Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
961     return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
962   }
963
964   Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
965     if (Constant *RC = dyn_cast<Constant>(RHS)) {
966       if (RC->isNullValue())
967         return LHS;  // LHS | 0 -> LHS
968       if (Constant *LC = dyn_cast<Constant>(LHS))
969         return Insert(Folder.CreateOr(LC, RC), Name);
970     }
971     return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
972   }
973   Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
974     return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
975   }
976   Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
977     return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
978   }
979
980   Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
981     if (Constant *LC = dyn_cast<Constant>(LHS))
982       if (Constant *RC = dyn_cast<Constant>(RHS))
983         return Insert(Folder.CreateXor(LC, RC), Name);
984     return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
985   }
986   Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
987     return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
988   }
989   Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
990     return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
991   }
992
993   Value *CreateBinOp(Instruction::BinaryOps Opc,
994                      Value *LHS, Value *RHS, const Twine &Name = "",
995                      MDNode *FPMathTag = nullptr) {
996     if (Constant *LC = dyn_cast<Constant>(LHS))
997       if (Constant *RC = dyn_cast<Constant>(RHS))
998         return Insert(Folder.CreateBinOp(Opc, LC, RC), Name);
999     llvm::Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1000     if (isa<FPMathOperator>(BinOp))
1001       BinOp = AddFPMathAttributes(BinOp, FPMathTag, FMF);
1002     return Insert(BinOp, Name);
1003   }
1004
1005   Value *CreateNeg(Value *V, const Twine &Name = "",
1006                    bool HasNUW = false, bool HasNSW = false) {
1007     if (Constant *VC = dyn_cast<Constant>(V))
1008       return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1009     BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1010     if (HasNUW) BO->setHasNoUnsignedWrap();
1011     if (HasNSW) BO->setHasNoSignedWrap();
1012     return BO;
1013   }
1014   Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1015     return CreateNeg(V, Name, false, true);
1016   }
1017   Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
1018     return CreateNeg(V, Name, true, false);
1019   }
1020   Value *CreateFNeg(Value *V, const Twine &Name = "",
1021                     MDNode *FPMathTag = nullptr) {
1022     if (Constant *VC = dyn_cast<Constant>(V))
1023       return Insert(Folder.CreateFNeg(VC), Name);
1024     return Insert(AddFPMathAttributes(BinaryOperator::CreateFNeg(V),
1025                                       FPMathTag, FMF), Name);
1026   }
1027   Value *CreateNot(Value *V, const Twine &Name = "") {
1028     if (Constant *VC = dyn_cast<Constant>(V))
1029       return Insert(Folder.CreateNot(VC), Name);
1030     return Insert(BinaryOperator::CreateNot(V), Name);
1031   }
1032
1033   //===--------------------------------------------------------------------===//
1034   // Instruction creation methods: Memory Instructions
1035   //===--------------------------------------------------------------------===//
1036
1037   AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1038                            const Twine &Name = "") {
1039     return Insert(new AllocaInst(Ty, ArraySize), Name);
1040   }
1041   // \brief Provided to resolve 'CreateLoad(Ptr, "...")' correctly, instead of
1042   // converting the string to 'bool' for the isVolatile parameter.
1043   LoadInst *CreateLoad(Value *Ptr, const char *Name) {
1044     return Insert(new LoadInst(Ptr), Name);
1045   }
1046   LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") {
1047     return Insert(new LoadInst(Ptr), Name);
1048   }
1049   LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1050     return Insert(new LoadInst(Ty, Ptr), Name);
1051   }
1052   LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") {
1053     return Insert(new LoadInst(Ptr, nullptr, isVolatile), Name);
1054   }
1055   StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1056     return Insert(new StoreInst(Val, Ptr, isVolatile));
1057   }
1058   // \brief Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")'
1059   // correctly, instead of converting the string to 'bool' for the isVolatile
1060   // parameter.
1061   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
1062     LoadInst *LI = CreateLoad(Ptr, Name);
1063     LI->setAlignment(Align);
1064     return LI;
1065   }
1066   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align,
1067                               const Twine &Name = "") {
1068     LoadInst *LI = CreateLoad(Ptr, Name);
1069     LI->setAlignment(Align);
1070     return LI;
1071   }
1072   LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, bool isVolatile,
1073                               const Twine &Name = "") {
1074     LoadInst *LI = CreateLoad(Ptr, isVolatile, Name);
1075     LI->setAlignment(Align);
1076     return LI;
1077   }
1078   StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
1079                                 bool isVolatile = false) {
1080     StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1081     SI->setAlignment(Align);
1082     return SI;
1083   }
1084   FenceInst *CreateFence(AtomicOrdering Ordering,
1085                          SynchronizationScope SynchScope = CrossThread,
1086                          const Twine &Name = "") {
1087     return Insert(new FenceInst(Context, Ordering, SynchScope), Name);
1088   }
1089   AtomicCmpXchgInst *
1090   CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New,
1091                       AtomicOrdering SuccessOrdering,
1092                       AtomicOrdering FailureOrdering,
1093                       SynchronizationScope SynchScope = CrossThread) {
1094     return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
1095                                         FailureOrdering, SynchScope));
1096   }
1097   AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val,
1098                                  AtomicOrdering Ordering,
1099                                SynchronizationScope SynchScope = CrossThread) {
1100     return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SynchScope));
1101   }
1102   Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1103                    const Twine &Name = "") {
1104     return CreateGEP(nullptr, Ptr, IdxList, Name);
1105   }
1106   Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1107                    const Twine &Name = "") {
1108     if (Constant *PC = dyn_cast<Constant>(Ptr)) {
1109       // Every index must be constant.
1110       size_t i, e;
1111       for (i = 0, e = IdxList.size(); i != e; ++i)
1112         if (!isa<Constant>(IdxList[i]))
1113           break;
1114       if (i == e)
1115         return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1116     }
1117     return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1118   }
1119   Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1120                            const Twine &Name = "") {
1121     return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1122   }
1123   Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1124                            const Twine &Name = "") {
1125     if (Constant *PC = dyn_cast<Constant>(Ptr)) {
1126       // Every index must be constant.
1127       size_t i, e;
1128       for (i = 0, e = IdxList.size(); i != e; ++i)
1129         if (!isa<Constant>(IdxList[i]))
1130           break;
1131       if (i == e)
1132         return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1133                       Name);
1134     }
1135     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1136   }
1137   Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1138     return CreateGEP(nullptr, Ptr, Idx, Name);
1139   }
1140   Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1141     if (Constant *PC = dyn_cast<Constant>(Ptr))
1142       if (Constant *IC = dyn_cast<Constant>(Idx))
1143         return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1144     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1145   }
1146   Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
1147                            const Twine &Name = "") {
1148     if (Constant *PC = dyn_cast<Constant>(Ptr))
1149       if (Constant *IC = dyn_cast<Constant>(Idx))
1150         return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1151     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1152   }
1153   Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
1154     return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
1155   }
1156   Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1157                             const Twine &Name = "") {
1158     Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1159
1160     if (Constant *PC = dyn_cast<Constant>(Ptr))
1161       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1162
1163     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1164   }
1165   Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1166                                     const Twine &Name = "") {
1167     Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1168
1169     if (Constant *PC = dyn_cast<Constant>(Ptr))
1170       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1171
1172     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1173   }
1174   Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1175                             const Twine &Name = "") {
1176     Value *Idxs[] = {
1177       ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1178       ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1179     };
1180
1181     if (Constant *PC = dyn_cast<Constant>(Ptr))
1182       return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1183
1184     return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1185   }
1186   Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1187                                     unsigned Idx1, const Twine &Name = "") {
1188     Value *Idxs[] = {
1189       ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1190       ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1191     };
1192
1193     if (Constant *PC = dyn_cast<Constant>(Ptr))
1194       return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1195
1196     return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1197   }
1198   Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
1199     Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1200
1201     if (Constant *PC = dyn_cast<Constant>(Ptr))
1202       return Insert(Folder.CreateGetElementPtr(nullptr, PC, Idx), Name);
1203
1204     return Insert(GetElementPtrInst::Create(nullptr, Ptr, Idx), Name);
1205   }
1206   Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
1207                                     const Twine &Name = "") {
1208     Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1209
1210     if (Constant *PC = dyn_cast<Constant>(Ptr))
1211       return Insert(Folder.CreateInBoundsGetElementPtr(nullptr, PC, Idx), Name);
1212
1213     return Insert(GetElementPtrInst::CreateInBounds(nullptr, Ptr, Idx), Name);
1214   }
1215   Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1216                     const Twine &Name = "") {
1217     Value *Idxs[] = {
1218       ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1219       ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1220     };
1221
1222     if (Constant *PC = dyn_cast<Constant>(Ptr))
1223       return Insert(Folder.CreateGetElementPtr(nullptr, PC, Idxs), Name);
1224
1225     return Insert(GetElementPtrInst::Create(nullptr, Ptr, Idxs), Name);
1226   }
1227   Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1228                                     const Twine &Name = "") {
1229     Value *Idxs[] = {
1230       ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1231       ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1232     };
1233
1234     if (Constant *PC = dyn_cast<Constant>(Ptr))
1235       return Insert(Folder.CreateInBoundsGetElementPtr(nullptr, PC, Idxs),
1236                     Name);
1237
1238     return Insert(GetElementPtrInst::CreateInBounds(nullptr, Ptr, Idxs), Name);
1239   }
1240   Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1241                          const Twine &Name = "") {
1242     return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1243   }
1244
1245   /// \brief Same as CreateGlobalString, but return a pointer with "i8*" type
1246   /// instead of a pointer to array of i8.
1247   Value *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
1248                                unsigned AddressSpace = 0) {
1249     GlobalVariable *gv = CreateGlobalString(Str, Name, AddressSpace);
1250     Value *zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1251     Value *Args[] = { zero, zero };
1252     return CreateInBoundsGEP(gv->getValueType(), gv, Args, Name);
1253   }
1254
1255   //===--------------------------------------------------------------------===//
1256   // Instruction creation methods: Cast/Conversion Operators
1257   //===--------------------------------------------------------------------===//
1258
1259   Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1260     return CreateCast(Instruction::Trunc, V, DestTy, Name);
1261   }
1262   Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1263     return CreateCast(Instruction::ZExt, V, DestTy, Name);
1264   }
1265   Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
1266     return CreateCast(Instruction::SExt, V, DestTy, Name);
1267   }
1268   /// \brief Create a ZExt or Trunc from the integer value V to DestTy. Return
1269   /// the value untouched if the type of V is already DestTy.
1270   Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
1271                            const Twine &Name = "") {
1272     assert(V->getType()->isIntOrIntVectorTy() &&
1273            DestTy->isIntOrIntVectorTy() &&
1274            "Can only zero extend/truncate integers!");
1275     Type *VTy = V->getType();
1276     if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1277       return CreateZExt(V, DestTy, Name);
1278     if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1279       return CreateTrunc(V, DestTy, Name);
1280     return V;
1281   }
1282   /// \brief Create a SExt or Trunc from the integer value V to DestTy. Return
1283   /// the value untouched if the type of V is already DestTy.
1284   Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
1285                            const Twine &Name = "") {
1286     assert(V->getType()->isIntOrIntVectorTy() &&
1287            DestTy->isIntOrIntVectorTy() &&
1288            "Can only sign extend/truncate integers!");
1289     Type *VTy = V->getType();
1290     if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1291       return CreateSExt(V, DestTy, Name);
1292     if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1293       return CreateTrunc(V, DestTy, Name);
1294     return V;
1295   }
1296   Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = ""){
1297     return CreateCast(Instruction::FPToUI, V, DestTy, Name);
1298   }
1299   Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = ""){
1300     return CreateCast(Instruction::FPToSI, V, DestTy, Name);
1301   }
1302   Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1303     return CreateCast(Instruction::UIToFP, V, DestTy, Name);
1304   }
1305   Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1306     return CreateCast(Instruction::SIToFP, V, DestTy, Name);
1307   }
1308   Value *CreateFPTrunc(Value *V, Type *DestTy,
1309                        const Twine &Name = "") {
1310     return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
1311   }
1312   Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
1313     return CreateCast(Instruction::FPExt, V, DestTy, Name);
1314   }
1315   Value *CreatePtrToInt(Value *V, Type *DestTy,
1316                         const Twine &Name = "") {
1317     return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
1318   }
1319   Value *CreateIntToPtr(Value *V, Type *DestTy,
1320                         const Twine &Name = "") {
1321     return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
1322   }
1323   Value *CreateBitCast(Value *V, Type *DestTy,
1324                        const Twine &Name = "") {
1325     return CreateCast(Instruction::BitCast, V, DestTy, Name);
1326   }
1327   Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
1328                              const Twine &Name = "") {
1329     return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
1330   }
1331   Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
1332                              const Twine &Name = "") {
1333     if (V->getType() == DestTy)
1334       return V;
1335     if (Constant *VC = dyn_cast<Constant>(V))
1336       return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
1337     return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
1338   }
1339   Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
1340                              const Twine &Name = "") {
1341     if (V->getType() == DestTy)
1342       return V;
1343     if (Constant *VC = dyn_cast<Constant>(V))
1344       return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
1345     return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
1346   }
1347   Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
1348                               const Twine &Name = "") {
1349     if (V->getType() == DestTy)
1350       return V;
1351     if (Constant *VC = dyn_cast<Constant>(V))
1352       return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
1353     return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
1354   }
1355   Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
1356                     const Twine &Name = "") {
1357     if (V->getType() == DestTy)
1358       return V;
1359     if (Constant *VC = dyn_cast<Constant>(V))
1360       return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
1361     return Insert(CastInst::Create(Op, V, DestTy), Name);
1362   }
1363   Value *CreatePointerCast(Value *V, Type *DestTy,
1364                            const Twine &Name = "") {
1365     if (V->getType() == DestTy)
1366       return V;
1367     if (Constant *VC = dyn_cast<Constant>(V))
1368       return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
1369     return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
1370   }
1371
1372   Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
1373                                              const Twine &Name = "") {
1374     if (V->getType() == DestTy)
1375       return V;
1376
1377     if (Constant *VC = dyn_cast<Constant>(V)) {
1378       return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
1379                     Name);
1380     }
1381
1382     return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
1383                   Name);
1384   }
1385
1386   Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
1387                        const Twine &Name = "") {
1388     if (V->getType() == DestTy)
1389       return V;
1390     if (Constant *VC = dyn_cast<Constant>(V))
1391       return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
1392     return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
1393   }
1394
1395   Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
1396                                 const Twine &Name = "") {
1397     if (V->getType() == DestTy)
1398       return V;
1399     if (V->getType()->getScalarType()->isPointerTy() &&
1400         DestTy->getScalarType()->isIntegerTy())
1401       return CreatePtrToInt(V, DestTy, Name);
1402     if (V->getType()->getScalarType()->isIntegerTy() &&
1403         DestTy->getScalarType()->isPointerTy())
1404       return CreateIntToPtr(V, DestTy, Name);
1405
1406     return CreateBitCast(V, DestTy, Name);
1407   }
1408
1409 private:
1410   // \brief Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
1411   // compile time error, instead of converting the string to bool for the
1412   // isSigned parameter.
1413   Value *CreateIntCast(Value *, Type *, const char *) = delete;
1414
1415 public:
1416   Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
1417     if (V->getType() == DestTy)
1418       return V;
1419     if (Constant *VC = dyn_cast<Constant>(V))
1420       return Insert(Folder.CreateFPCast(VC, DestTy), Name);
1421     return Insert(CastInst::CreateFPCast(V, DestTy), Name);
1422   }
1423
1424   //===--------------------------------------------------------------------===//
1425   // Instruction creation methods: Compare Instructions
1426   //===--------------------------------------------------------------------===//
1427
1428   Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
1429     return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
1430   }
1431   Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
1432     return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
1433   }
1434   Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
1435     return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
1436   }
1437   Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
1438     return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
1439   }
1440   Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
1441     return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
1442   }
1443   Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
1444     return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
1445   }
1446   Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
1447     return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
1448   }
1449   Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
1450     return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
1451   }
1452   Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
1453     return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
1454   }
1455   Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
1456     return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
1457   }
1458
1459   Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
1460                        MDNode *FPMathTag = nullptr) {
1461     return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
1462   }
1463   Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
1464                        MDNode *FPMathTag = nullptr) {
1465     return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
1466   }
1467   Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
1468                        MDNode *FPMathTag = nullptr) {
1469     return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
1470   }
1471   Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
1472                        MDNode *FPMathTag = nullptr) {
1473     return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
1474   }
1475   Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
1476                        MDNode *FPMathTag = nullptr) {
1477     return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
1478   }
1479   Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
1480                        MDNode *FPMathTag = nullptr) {
1481     return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
1482   }
1483   Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
1484                        MDNode *FPMathTag = nullptr) {
1485     return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
1486   }
1487   Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
1488                        MDNode *FPMathTag = nullptr) {
1489     return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
1490   }
1491   Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
1492                        MDNode *FPMathTag = nullptr) {
1493     return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
1494   }
1495   Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
1496                        MDNode *FPMathTag = nullptr) {
1497     return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
1498   }
1499   Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
1500                        MDNode *FPMathTag = nullptr) {
1501     return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
1502   }
1503   Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
1504                        MDNode *FPMathTag = nullptr) {
1505     return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
1506   }
1507   Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
1508                        MDNode *FPMathTag = nullptr) {
1509     return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
1510   }
1511   Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
1512                        MDNode *FPMathTag = nullptr) {
1513     return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
1514   }
1515
1516   Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
1517                     const Twine &Name = "") {
1518     if (Constant *LC = dyn_cast<Constant>(LHS))
1519       if (Constant *RC = dyn_cast<Constant>(RHS))
1520         return Insert(Folder.CreateICmp(P, LC, RC), Name);
1521     return Insert(new ICmpInst(P, LHS, RHS), Name);
1522   }
1523   Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
1524                     const Twine &Name = "", MDNode *FPMathTag = nullptr) {
1525     if (Constant *LC = dyn_cast<Constant>(LHS))
1526       if (Constant *RC = dyn_cast<Constant>(RHS))
1527         return Insert(Folder.CreateFCmp(P, LC, RC), Name);
1528     return Insert(AddFPMathAttributes(new FCmpInst(P, LHS, RHS),
1529                                       FPMathTag, FMF), Name);
1530   }
1531
1532   //===--------------------------------------------------------------------===//
1533   // Instruction creation methods: Other Instructions
1534   //===--------------------------------------------------------------------===//
1535
1536   PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
1537                      const Twine &Name = "") {
1538     return Insert(PHINode::Create(Ty, NumReservedValues), Name);
1539   }
1540
1541   CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
1542                        ArrayRef<OperandBundleDef> OpBundles = None,
1543                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
1544     CallInst *CI = CallInst::Create(Callee, Args, OpBundles);
1545     if (isa<FPMathOperator>(CI))
1546       CI = cast<CallInst>(AddFPMathAttributes(CI, FPMathTag, FMF));
1547     return Insert(CI, Name);
1548   }
1549
1550   CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
1551                        const Twine &Name, MDNode *FPMathTag = nullptr) {
1552     PointerType *PTy = cast<PointerType>(Callee->getType());
1553     FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
1554     return CreateCall(FTy, Callee, Args, Name, FPMathTag);
1555   }
1556
1557   CallInst *CreateCall(llvm::FunctionType *FTy, Value *Callee,
1558                        ArrayRef<Value *> Args, const Twine &Name = "",
1559                        MDNode *FPMathTag = nullptr) {
1560     CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
1561     if (isa<FPMathOperator>(CI))
1562       CI = cast<CallInst>(AddFPMathAttributes(CI, FPMathTag, FMF));
1563     return Insert(CI, Name);
1564   }
1565
1566   CallInst *CreateCall(Function *Callee, ArrayRef<Value *> Args,
1567                        const Twine &Name = "", MDNode *FPMathTag = nullptr) {
1568     return CreateCall(Callee->getFunctionType(), Callee, Args, Name, FPMathTag);
1569   }
1570
1571   Value *CreateSelect(Value *C, Value *True, Value *False,
1572                       const Twine &Name = "") {
1573     if (Constant *CC = dyn_cast<Constant>(C))
1574       if (Constant *TC = dyn_cast<Constant>(True))
1575         if (Constant *FC = dyn_cast<Constant>(False))
1576           return Insert(Folder.CreateSelect(CC, TC, FC), Name);
1577     return Insert(SelectInst::Create(C, True, False), Name);
1578   }
1579
1580   VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
1581     return Insert(new VAArgInst(List, Ty), Name);
1582   }
1583
1584   Value *CreateExtractElement(Value *Vec, Value *Idx,
1585                               const Twine &Name = "") {
1586     if (Constant *VC = dyn_cast<Constant>(Vec))
1587       if (Constant *IC = dyn_cast<Constant>(Idx))
1588         return Insert(Folder.CreateExtractElement(VC, IC), Name);
1589     return Insert(ExtractElementInst::Create(Vec, Idx), Name);
1590   }
1591
1592   Value *CreateExtractElement(Value *Vec, uint64_t Idx,
1593                               const Twine &Name = "") {
1594     return CreateExtractElement(Vec, getInt64(Idx), Name);
1595   }
1596
1597   Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
1598                              const Twine &Name = "") {
1599     if (Constant *VC = dyn_cast<Constant>(Vec))
1600       if (Constant *NC = dyn_cast<Constant>(NewElt))
1601         if (Constant *IC = dyn_cast<Constant>(Idx))
1602           return Insert(Folder.CreateInsertElement(VC, NC, IC), Name);
1603     return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
1604   }
1605
1606   Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
1607                              const Twine &Name = "") {
1608     return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
1609   }
1610
1611   Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
1612                              const Twine &Name = "") {
1613     if (Constant *V1C = dyn_cast<Constant>(V1))
1614       if (Constant *V2C = dyn_cast<Constant>(V2))
1615         if (Constant *MC = dyn_cast<Constant>(Mask))
1616           return Insert(Folder.CreateShuffleVector(V1C, V2C, MC), Name);
1617     return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
1618   }
1619
1620   Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<int> IntMask,
1621                              const Twine &Name = "") {
1622     size_t MaskSize = IntMask.size();
1623     SmallVector<Constant*, 8> MaskVec(MaskSize);
1624     for (size_t i = 0; i != MaskSize; ++i)
1625       MaskVec[i] = getInt32(IntMask[i]);
1626     Value *Mask = ConstantVector::get(MaskVec);
1627     return CreateShuffleVector(V1, V2, Mask, Name);
1628   }
1629
1630   Value *CreateExtractValue(Value *Agg,
1631                             ArrayRef<unsigned> Idxs,
1632                             const Twine &Name = "") {
1633     if (Constant *AggC = dyn_cast<Constant>(Agg))
1634       return Insert(Folder.CreateExtractValue(AggC, Idxs), Name);
1635     return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
1636   }
1637
1638   Value *CreateInsertValue(Value *Agg, Value *Val,
1639                            ArrayRef<unsigned> Idxs,
1640                            const Twine &Name = "") {
1641     if (Constant *AggC = dyn_cast<Constant>(Agg))
1642       if (Constant *ValC = dyn_cast<Constant>(Val))
1643         return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
1644     return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
1645   }
1646
1647   LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
1648                                    const Twine &Name = "") {
1649     return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
1650   }
1651
1652   //===--------------------------------------------------------------------===//
1653   // Utility creation methods
1654   //===--------------------------------------------------------------------===//
1655
1656   /// \brief Return an i1 value testing if \p Arg is null.
1657   Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
1658     return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
1659                         Name);
1660   }
1661
1662   /// \brief Return an i1 value testing if \p Arg is not null.
1663   Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
1664     return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
1665                         Name);
1666   }
1667
1668   /// \brief Return the i64 difference between two pointer values, dividing out
1669   /// the size of the pointed-to objects.
1670   ///
1671   /// This is intended to implement C-style pointer subtraction. As such, the
1672   /// pointers must be appropriately aligned for their element types and
1673   /// pointing into the same object.
1674   Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
1675     assert(LHS->getType() == RHS->getType() &&
1676            "Pointer subtraction operand types must match!");
1677     PointerType *ArgType = cast<PointerType>(LHS->getType());
1678     Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
1679     Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
1680     Value *Difference = CreateSub(LHS_int, RHS_int);
1681     return CreateExactSDiv(Difference,
1682                            ConstantExpr::getSizeOf(ArgType->getElementType()),
1683                            Name);
1684   }
1685
1686   /// \brief Create an invariant.group.barrier intrinsic call, that stops
1687   /// optimizer to propagate equality using invariant.group metadata.
1688   /// If Ptr type is different from i8*, it's casted to i8* before call
1689   /// and casted back to Ptr type after call.
1690   Value *CreateInvariantGroupBarrier(Value *Ptr) {
1691     Module *M = BB->getParent()->getParent();
1692     Function *FnInvariantGroupBarrier = Intrinsic::getDeclaration(M,
1693             Intrinsic::invariant_group_barrier);
1694
1695     Type *ArgumentAndReturnType = FnInvariantGroupBarrier->getReturnType();
1696     assert(ArgumentAndReturnType ==
1697         FnInvariantGroupBarrier->getFunctionType()->getParamType(0) &&
1698         "InvariantGroupBarrier should take and return the same type");
1699     Type *PtrType = Ptr->getType();
1700
1701     bool PtrTypeConversionNeeded = PtrType != ArgumentAndReturnType;
1702     if (PtrTypeConversionNeeded)
1703       Ptr = CreateBitCast(Ptr, ArgumentAndReturnType);
1704
1705     CallInst *Fn = CreateCall(FnInvariantGroupBarrier, {Ptr});
1706
1707     if (PtrTypeConversionNeeded)
1708       return CreateBitCast(Fn, PtrType);
1709     return Fn;
1710   }
1711
1712   /// \brief Return a vector value that contains \arg V broadcasted to \p
1713   /// NumElts elements.
1714   Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") {
1715     assert(NumElts > 0 && "Cannot splat to an empty vector!");
1716
1717     // First insert it into an undef vector so we can shuffle it.
1718     Type *I32Ty = getInt32Ty();
1719     Value *Undef = UndefValue::get(VectorType::get(V->getType(), NumElts));
1720     V = CreateInsertElement(Undef, V, ConstantInt::get(I32Ty, 0),
1721                             Name + ".splatinsert");
1722
1723     // Shuffle the value across the desired number of elements.
1724     Value *Zeros = ConstantAggregateZero::get(VectorType::get(I32Ty, NumElts));
1725     return CreateShuffleVector(V, Undef, Zeros, Name + ".splat");
1726   }
1727
1728   /// \brief Return a value that has been extracted from a larger integer type.
1729   Value *CreateExtractInteger(const DataLayout &DL, Value *From,
1730                               IntegerType *ExtractedTy, uint64_t Offset,
1731                               const Twine &Name) {
1732     IntegerType *IntTy = cast<IntegerType>(From->getType());
1733     assert(DL.getTypeStoreSize(ExtractedTy) + Offset <=
1734                DL.getTypeStoreSize(IntTy) &&
1735            "Element extends past full value");
1736     uint64_t ShAmt = 8 * Offset;
1737     Value *V = From;
1738     if (DL.isBigEndian())
1739       ShAmt = 8 * (DL.getTypeStoreSize(IntTy) -
1740                    DL.getTypeStoreSize(ExtractedTy) - Offset);
1741     if (ShAmt) {
1742       V = CreateLShr(V, ShAmt, Name + ".shift");
1743     }
1744     assert(ExtractedTy->getBitWidth() <= IntTy->getBitWidth() &&
1745            "Cannot extract to a larger integer!");
1746     if (ExtractedTy != IntTy) {
1747       V = CreateTrunc(V, ExtractedTy, Name + ".trunc");
1748     }
1749     return V;
1750   }
1751
1752   /// \brief Create an assume intrinsic call that represents an alignment
1753   /// assumption on the provided pointer.
1754   ///
1755   /// An optional offset can be provided, and if it is provided, the offset
1756   /// must be subtracted from the provided pointer to get the pointer with the
1757   /// specified alignment.
1758   CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
1759                                       unsigned Alignment,
1760                                       Value *OffsetValue = nullptr) {
1761     assert(isa<PointerType>(PtrValue->getType()) &&
1762            "trying to create an alignment assumption on a non-pointer?");
1763
1764     PointerType *PtrTy = cast<PointerType>(PtrValue->getType());
1765     Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
1766     Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
1767
1768     Value *Mask = ConstantInt::get(IntPtrTy,
1769       Alignment > 0 ? Alignment - 1 : 0);
1770     if (OffsetValue) {
1771       bool IsOffsetZero = false;
1772       if (ConstantInt *CI = dyn_cast<ConstantInt>(OffsetValue))
1773         IsOffsetZero = CI->isZero();
1774
1775       if (!IsOffsetZero) {
1776         if (OffsetValue->getType() != IntPtrTy)
1777           OffsetValue = CreateIntCast(OffsetValue, IntPtrTy, /*isSigned*/ true,
1778                                       "offsetcast");
1779         PtrIntValue = CreateSub(PtrIntValue, OffsetValue, "offsetptr");
1780       }
1781     }
1782
1783     Value *Zero = ConstantInt::get(IntPtrTy, 0);
1784     Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
1785     Value *InvCond = CreateICmpEQ(MaskedPtr, Zero, "maskcond");
1786
1787     return CreateAssumption(InvCond);
1788   }
1789 };
1790
1791 // Create wrappers for C Binding types (see CBindingWrapping.h).
1792 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)
1793
1794 } // end namespace llvm
1795
1796 #endif // LLVM_IR_IRBUILDER_H