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