LLVM  13.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 = ExceptionBehaviorToStr(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 = RoundingModeToStr(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->addAttribute(AttributeList::FunctionIndex, 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.
483  ConstantInt *getInt64(uint64_t C) {
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.
489  ConstantInt *getIntN(unsigned N, uint64_t C) {
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.
580  CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size,
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 *CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src,
651  MaybeAlign SrcAlign, Value *Size);
652 
653  /// Create and insert an element unordered-atomic memcpy between the
654  /// specified pointers.
655  ///
656  /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
657  ///
658  /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
659  /// specified, it will be added to the instruction. Likewise with alias.scope
660  /// and noalias tags.
662  Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
663  uint32_t ElementSize, MDNode *TBAATag = nullptr,
664  MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
665  MDNode *NoAliasTag = nullptr);
666 
667  CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
668  MaybeAlign SrcAlign, uint64_t Size,
669  bool isVolatile = false, MDNode *TBAATag = nullptr,
670  MDNode *ScopeTag = nullptr,
671  MDNode *NoAliasTag = nullptr) {
672  return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
673  isVolatile, TBAATag, ScopeTag, NoAliasTag);
674  }
675 
676  CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
677  MaybeAlign SrcAlign, Value *Size,
678  bool isVolatile = false, MDNode *TBAATag = nullptr,
679  MDNode *ScopeTag = nullptr,
680  MDNode *NoAliasTag = nullptr);
681 
682  /// \brief Create and insert an element unordered-atomic memmove between the
683  /// specified pointers.
684  ///
685  /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,
686  /// respectively.
687  ///
688  /// If the pointers aren't i8*, they will be converted. If a TBAA tag is
689  /// specified, it will be added to the instruction. Likewise with alias.scope
690  /// and noalias tags.
692  Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
693  uint32_t ElementSize, MDNode *TBAATag = nullptr,
694  MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
695  MDNode *NoAliasTag = nullptr);
696 
697  /// Create a vector fadd reduction intrinsic of the source vector.
698  /// The first parameter is a scalar accumulator value for ordered reductions.
699  CallInst *CreateFAddReduce(Value *Acc, Value *Src);
700 
701  /// Create a vector fmul reduction intrinsic of the source vector.
702  /// The first parameter is a scalar accumulator value for ordered reductions.
703  CallInst *CreateFMulReduce(Value *Acc, Value *Src);
704 
705  /// Create a vector int add reduction intrinsic of the source vector.
707 
708  /// Create a vector int mul reduction intrinsic of the source vector.
710 
711  /// Create a vector int AND reduction intrinsic of the source vector.
713 
714  /// Create a vector int OR reduction intrinsic of the source vector.
716 
717  /// Create a vector int XOR reduction intrinsic of the source vector.
719 
720  /// Create a vector integer max reduction intrinsic of the source
721  /// vector.
722  CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
723 
724  /// Create a vector integer min reduction intrinsic of the source
725  /// vector.
726  CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
727 
728  /// Create a vector float max reduction intrinsic of the source
729  /// vector.
731 
732  /// Create a vector float min reduction intrinsic of the source
733  /// vector.
735 
736  /// Create a lifetime.start intrinsic.
737  ///
738  /// If the pointer isn't i8* it will be converted.
740 
741  /// Create a lifetime.end intrinsic.
742  ///
743  /// If the pointer isn't i8* it will be converted.
744  CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
745 
746  /// Create a call to invariant.start intrinsic.
747  ///
748  /// If the pointer isn't i8* it will be converted.
750 
751  /// Create a call to Masked Load intrinsic
752  CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask,
753  Value *PassThru = nullptr, const Twine &Name = "");
754 
755  /// Create a call to Masked Store intrinsic
756  CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
757  Value *Mask);
758 
759  /// Create a call to Masked Gather intrinsic
760  CallInst *CreateMaskedGather(Value *Ptrs, Align Alignment,
761  Value *Mask = nullptr, Value *PassThru = nullptr,
762  const Twine &Name = "");
763 
764  /// Create a call to Masked Scatter intrinsic
765  CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,
766  Value *Mask = nullptr);
767 
768  /// Create an assume intrinsic call that allows the optimizer to
769  /// assume that the provided condition will be true.
770  ///
771  /// The optional argument \p OpBundles specifies operand bundles that are
772  /// added to the call instruction.
775 
776  /// Create a llvm.experimental.noalias.scope.decl intrinsic call.
780  MetadataAsValue::get(Context, ScopeTag));
781  }
782 
783  /// Create a call to the experimental.gc.statepoint intrinsic to
784  /// start a new statepoint sequence.
785  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
786  Value *ActualCallee,
787  ArrayRef<Value *> CallArgs,
788  Optional<ArrayRef<Value *>> DeoptArgs,
789  ArrayRef<Value *> GCArgs,
790  const Twine &Name = "");
791 
792  /// Create a call to the experimental.gc.statepoint intrinsic to
793  /// start a new statepoint sequence.
794  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
795  Value *ActualCallee, uint32_t Flags,
796  ArrayRef<Value *> CallArgs,
797  Optional<ArrayRef<Use>> TransitionArgs,
798  Optional<ArrayRef<Use>> DeoptArgs,
799  ArrayRef<Value *> GCArgs,
800  const Twine &Name = "");
801 
802  /// Conveninence function for the common case when CallArgs are filled
803  /// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
804  /// .get()'ed to get the Value pointer.
805  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
806  Value *ActualCallee, ArrayRef<Use> CallArgs,
807  Optional<ArrayRef<Value *>> DeoptArgs,
808  ArrayRef<Value *> GCArgs,
809  const Twine &Name = "");
810 
811  /// Create an invoke to the experimental.gc.statepoint intrinsic to
812  /// start a new statepoint sequence.
813  InvokeInst *
814  CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
815  Value *ActualInvokee, BasicBlock *NormalDest,
816  BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
817  Optional<ArrayRef<Value *>> DeoptArgs,
818  ArrayRef<Value *> GCArgs, const Twine &Name = "");
819 
820  /// Create an invoke to the experimental.gc.statepoint intrinsic to
821  /// start a new statepoint sequence.
823  uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
824  BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
825  ArrayRef<Value *> InvokeArgs, Optional<ArrayRef<Use>> TransitionArgs,
826  Optional<ArrayRef<Use>> DeoptArgs, ArrayRef<Value *> GCArgs,
827  const Twine &Name = "");
828 
829  // Convenience function for the common case when CallArgs are filled in using
830  // makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
831  // get the Value *.
832  InvokeInst *
833  CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
834  Value *ActualInvokee, BasicBlock *NormalDest,
835  BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
836  Optional<ArrayRef<Value *>> DeoptArgs,
837  ArrayRef<Value *> GCArgs, const Twine &Name = "");
838 
839  /// Create a call to the experimental.gc.result intrinsic to extract
840  /// the result from a call wrapped in a statepoint.
841  CallInst *CreateGCResult(Instruction *Statepoint,
842  Type *ResultType,
843  const Twine &Name = "");
844 
845  /// Create a call to the experimental.gc.relocate intrinsics to
846  /// project the relocated value of one pointer from the statepoint.
848  int BaseOffset,
849  int DerivedOffset,
850  Type *ResultType,
851  const Twine &Name = "");
852 
853  /// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
854  /// will be the same type as that of \p Scaling.
855  Value *CreateVScale(Constant *Scaling, const Twine &Name = "");
856 
857  /// Creates a vector of type \p DstType with the linear sequence <0, 1, ...>
858  Value *CreateStepVector(Type *DstType, const Twine &Name = "");
859 
860  /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
861  /// type.
863  Instruction *FMFSource = nullptr,
864  const Twine &Name = "");
865 
866  /// Create a call to intrinsic \p ID with 2 operands which is mangled on the
867  /// first type.
869  Instruction *FMFSource = nullptr,
870  const Twine &Name = "");
871 
872  /// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If
873  /// \p FMFSource is provided, copy fast-math-flags from that instruction to
874  /// the intrinsic.
877  Instruction *FMFSource = nullptr,
878  const Twine &Name = "");
879 
880  /// Create call to the minnum intrinsic.
881  CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
882  return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
883  }
884 
885  /// Create call to the maxnum intrinsic.
886  CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
887  return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
888  }
889 
890  /// Create call to the minimum intrinsic.
891  CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
892  return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
893  }
894 
895  /// Create call to the maximum intrinsic.
896  CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
897  return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
898  }
899 
900  /// Create a call to the experimental.vector.extract intrinsic.
901  CallInst *CreateExtractVector(Type *DstType, Value *SrcVec, Value *Idx,
902  const Twine &Name = "") {
903  return CreateIntrinsic(Intrinsic::experimental_vector_extract,
904  {DstType, SrcVec->getType()}, {SrcVec, Idx}, nullptr,
905  Name);
906  }
907 
908  /// Create a call to the experimental.vector.insert intrinsic.
909  CallInst *CreateInsertVector(Type *DstType, Value *SrcVec, Value *SubVec,
910  Value *Idx, const Twine &Name = "") {
911  return CreateIntrinsic(Intrinsic::experimental_vector_insert,
912  {DstType, SubVec->getType()}, {SrcVec, SubVec, Idx},
913  nullptr, Name);
914  }
915 
916 private:
917  /// Create a call to a masked intrinsic with given Id.
918  CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
919  ArrayRef<Type *> OverloadedTypes,
920  const Twine &Name = "");
921 
922  Value *getCastedInt8PtrValue(Value *Ptr);
923 
924  //===--------------------------------------------------------------------===//
925  // Instruction creation methods: Terminators
926  //===--------------------------------------------------------------------===//
927 
928 private:
929  /// Helper to add branch weight and unpredictable metadata onto an
930  /// instruction.
931  /// \returns The annotated instruction.
932  template <typename InstTy>
933  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
934  if (Weights)
935  I->setMetadata(LLVMContext::MD_prof, Weights);
936  if (Unpredictable)
937  I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
938  return I;
939  }
940 
941 public:
942  /// Create a 'ret void' instruction.
945  }
946 
947  /// Create a 'ret <val>' instruction.
949  return Insert(ReturnInst::Create(Context, V));
950  }
951 
952  /// Create a sequence of N insertvalue instructions,
953  /// with one Value from the retVals array each, that build a aggregate
954  /// return value one value at a time, and a ret instruction to return
955  /// the resulting aggregate value.
956  ///
957  /// This is a convenience function for code that uses aggregate return values
958  /// as a vehicle for having multiple return values.
959  ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
961  for (unsigned i = 0; i != N; ++i)
962  V = CreateInsertValue(V, retVals[i], i, "mrv");
963  return Insert(ReturnInst::Create(Context, V));
964  }
965 
966  /// Create an unconditional 'br label X' instruction.
968  return Insert(BranchInst::Create(Dest));
969  }
970 
971  /// Create a conditional 'br Cond, TrueDest, FalseDest'
972  /// instruction.
974  MDNode *BranchWeights = nullptr,
975  MDNode *Unpredictable = nullptr) {
976  return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
977  BranchWeights, Unpredictable));
978  }
979 
980  /// Create a conditional 'br Cond, TrueDest, FalseDest'
981  /// instruction. Copy branch meta data if available.
983  Instruction *MDSrc) {
984  BranchInst *Br = BranchInst::Create(True, False, Cond);
985  if (MDSrc) {
986  unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
987  LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
988  Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
989  }
990  return Insert(Br);
991  }
992 
993  /// Create a switch instruction with the specified value, default dest,
994  /// and with a hint for the number of cases that will be added (for efficient
995  /// allocation).
996  SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
997  MDNode *BranchWeights = nullptr,
998  MDNode *Unpredictable = nullptr) {
999  return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
1000  BranchWeights, Unpredictable));
1001  }
1002 
1003  /// Create an indirect branch instruction with the specified address
1004  /// operand, with an optional hint for the number of destinations that will be
1005  /// added (for efficient allocation).
1006  IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
1007  return Insert(IndirectBrInst::Create(Addr, NumDests));
1008  }
1009 
1010  /// Create an invoke instruction.
1012  BasicBlock *NormalDest, BasicBlock *UnwindDest,
1014  ArrayRef<OperandBundleDef> OpBundles,
1015  const Twine &Name = "") {
1016  InvokeInst *II =
1017  InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles);
1018  if (IsFPConstrained)
1020  return Insert(II, Name);
1021  }
1023  BasicBlock *NormalDest, BasicBlock *UnwindDest,
1025  const Twine &Name = "") {
1026  InvokeInst *II =
1027  InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args);
1028  if (IsFPConstrained)
1030  return Insert(II, Name);
1031  }
1032 
1034  BasicBlock *UnwindDest, ArrayRef<Value *> Args,
1035  ArrayRef<OperandBundleDef> OpBundles,
1036  const Twine &Name = "") {
1037  return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1038  NormalDest, UnwindDest, Args, OpBundles, Name);
1039  }
1040 
1042  BasicBlock *UnwindDest,
1044  const Twine &Name = "") {
1045  return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
1046  NormalDest, UnwindDest, Args, Name);
1047  }
1048 
1049  /// \brief Create a callbr instruction.
1051  BasicBlock *DefaultDest,
1052  ArrayRef<BasicBlock *> IndirectDests,
1054  const Twine &Name = "") {
1055  return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
1056  Args), Name);
1057  }
1059  BasicBlock *DefaultDest,
1060  ArrayRef<BasicBlock *> IndirectDests,
1062  ArrayRef<OperandBundleDef> OpBundles,
1063  const Twine &Name = "") {
1064  return Insert(
1065  CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
1066  OpBundles), Name);
1067  }
1068 
1070  ArrayRef<BasicBlock *> IndirectDests,
1072  const Twine &Name = "") {
1073  return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1074  DefaultDest, IndirectDests, Args, Name);
1075  }
1077  ArrayRef<BasicBlock *> IndirectDests,
1079  ArrayRef<OperandBundleDef> OpBundles,
1080  const Twine &Name = "") {
1081  return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1082  DefaultDest, IndirectDests, Args, Name);
1083  }
1084 
1086  return Insert(ResumeInst::Create(Exn));
1087  }
1088 
1090  BasicBlock *UnwindBB = nullptr) {
1091  return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1092  }
1093 
1095  unsigned NumHandlers,
1096  const Twine &Name = "") {
1097  return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1098  Name);
1099  }
1100 
1102  const Twine &Name = "") {
1103  return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1104  }
1105 
1108  const Twine &Name = "") {
1109  return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1110  }
1111 
1113  return Insert(CatchReturnInst::Create(CatchPad, BB));
1114  }
1115 
1117  return Insert(new UnreachableInst(Context));
1118  }
1119 
1120  //===--------------------------------------------------------------------===//
1121  // Instruction creation methods: Binary Operators
1122  //===--------------------------------------------------------------------===//
1123 private:
1124  BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1125  Value *LHS, Value *RHS,
1126  const Twine &Name,
1127  bool HasNUW, bool HasNSW) {
1128  BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1129  if (HasNUW) BO->setHasNoUnsignedWrap();
1130  if (HasNSW) BO->setHasNoSignedWrap();
1131  return BO;
1132  }
1133 
1134  Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1135  FastMathFlags FMF) const {
1136  if (!FPMD)
1137  FPMD = DefaultFPMathTag;
1138  if (FPMD)
1139  I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1140  I->setFastMathFlags(FMF);
1141  return I;
1142  }
1143 
1144  Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
1145  Value *R, const Twine &Name) const {
1146  auto *LC = dyn_cast<Constant>(L);
1147  auto *RC = dyn_cast<Constant>(R);
1148  return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
1149  }
1150 
1151  Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) {
1153 
1154  if (Rounding.hasValue())
1155  UseRounding = Rounding.getValue();
1156 
1157  Optional<StringRef> RoundingStr = RoundingModeToStr(UseRounding);
1158  assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
1159  auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
1160 
1161  return MetadataAsValue::get(Context, RoundingMDS);
1162  }
1163 
1164  Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) {
1166 
1167  if (Except.hasValue())
1168  UseExcept = Except.getValue();
1169 
1170  Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(UseExcept);
1171  assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
1172  auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
1173 
1174  return MetadataAsValue::get(Context, ExceptMDS);
1175  }
1176 
1177  Value *getConstrainedFPPredicate(CmpInst::Predicate Predicate) {
1181  "Invalid constrained FP comparison predicate!");
1182 
1183  StringRef PredicateStr = CmpInst::getPredicateName(Predicate);
1184  auto *PredicateMDS = MDString::get(Context, PredicateStr);
1185 
1186  return MetadataAsValue::get(Context, PredicateMDS);
1187  }
1188 
1189 public:
1190  Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
1191  bool HasNUW = false, bool HasNSW = false) {
1192  if (auto *LC = dyn_cast<Constant>(LHS))
1193  if (auto *RC = dyn_cast<Constant>(RHS))
1194  return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1195  return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1196  HasNUW, HasNSW);
1197  }
1198 
1199  Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1200  return CreateAdd(LHS, RHS, Name, false, true);
1201  }
1202 
1203  Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1204  return CreateAdd(LHS, RHS, Name, true, false);
1205  }
1206 
1207  Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
1208  bool HasNUW = false, bool HasNSW = false) {
1209  if (auto *LC = dyn_cast<Constant>(LHS))
1210  if (auto *RC = dyn_cast<Constant>(RHS))
1211  return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1212  return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1213  HasNUW, HasNSW);
1214  }
1215 
1216  Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1217  return CreateSub(LHS, RHS, Name, false, true);
1218  }
1219 
1220  Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1221  return CreateSub(LHS, RHS, Name, true, false);
1222  }
1223 
1224  Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
1225  bool HasNUW = false, bool HasNSW = false) {
1226  if (auto *LC = dyn_cast<Constant>(LHS))
1227  if (auto *RC = dyn_cast<Constant>(RHS))
1228  return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1229  return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1230  HasNUW, HasNSW);
1231  }
1232 
1233  Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1234  return CreateMul(LHS, RHS, Name, false, true);
1235  }
1236 
1237  Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1238  return CreateMul(LHS, RHS, Name, true, false);
1239  }
1240 
1241  Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1242  bool isExact = false) {
1243  if (auto *LC = dyn_cast<Constant>(LHS))
1244  if (auto *RC = dyn_cast<Constant>(RHS))
1245  return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1246  if (!isExact)
1247  return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1248  return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1249  }
1250 
1251  Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1252  return CreateUDiv(LHS, RHS, Name, true);
1253  }
1254 
1255  Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1256  bool isExact = false) {
1257  if (auto *LC = dyn_cast<Constant>(LHS))
1258  if (auto *RC = dyn_cast<Constant>(RHS))
1259  return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1260  if (!isExact)
1261  return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1262  return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1263  }
1264 
1265  Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1266  return CreateSDiv(LHS, RHS, Name, true);
1267  }
1268 
1269  Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1270  if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) return V;
1271  return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1272  }
1273 
1274  Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1275  if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) return V;
1276  return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1277  }
1278 
1279  Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
1280  bool HasNUW = false, bool HasNSW = false) {
1281  if (auto *LC = dyn_cast<Constant>(LHS))
1282  if (auto *RC = dyn_cast<Constant>(RHS))
1283  return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1284  return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1285  HasNUW, HasNSW);
1286  }
1287 
1288  Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
1289  bool HasNUW = false, bool HasNSW = false) {
1290  return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1291  HasNUW, HasNSW);
1292  }
1293 
1294  Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
1295  bool HasNUW = false, bool HasNSW = false) {
1296  return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1297  HasNUW, HasNSW);
1298  }
1299 
1300  Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
1301  bool isExact = false) {
1302  if (auto *LC = dyn_cast<Constant>(LHS))
1303  if (auto *RC = dyn_cast<Constant>(RHS))
1304  return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1305  if (!isExact)
1306  return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1307  return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1308  }
1309 
1310  Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1311  bool isExact = false) {
1312  return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1313  }
1314 
1315  Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1316  bool isExact = false) {
1317  return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1318  }
1319 
1320  Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
1321  bool isExact = false) {
1322  if (auto *LC = dyn_cast<Constant>(LHS))
1323  if (auto *RC = dyn_cast<Constant>(RHS))
1324  return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1325  if (!isExact)
1326  return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1327  return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1328  }
1329 
1330  Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1331  bool isExact = false) {
1332  return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1333  }
1334 
1335  Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1336  bool isExact = false) {
1337  return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1338  }
1339 
1340  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1341  if (auto *RC = dyn_cast<Constant>(RHS)) {
1342  if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1343  return LHS; // LHS & -1 -> LHS
1344  if (auto *LC = dyn_cast<Constant>(LHS))
1345  return Insert(Folder.CreateAnd(LC, RC), Name);
1346  }
1347  return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1348  }
1349 
1350  Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1351  return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1352  }
1353 
1354  Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1355  return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1356  }
1357 
1359  assert(!Ops.empty());
1360  Value *Accum = Ops[0];
1361  for (unsigned i = 1; i < Ops.size(); i++)
1362  Accum = CreateAnd(Accum, Ops[i]);
1363  return Accum;
1364  }
1365 
1366  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1367  if (auto *RC = dyn_cast<Constant>(RHS)) {
1368  if (RC->isNullValue())
1369  return LHS; // LHS | 0 -> LHS
1370  if (auto *LC = dyn_cast<Constant>(LHS))
1371  return Insert(Folder.CreateOr(LC, RC), Name);
1372  }
1373  return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1374  }
1375 
1376  Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1377  return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1378  }
1379 
1380  Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1381  return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1382  }
1383 
1385  assert(!Ops.empty());
1386  Value *Accum = Ops[0];
1387  for (unsigned i = 1; i < Ops.size(); i++)
1388  Accum = CreateOr(Accum, Ops[i]);
1389  return Accum;
1390  }
1391 
1392  Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1393  if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) return V;
1394  return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1395  }
1396 
1397  Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1398  return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1399  }
1400 
1401  Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1402  return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1403  }
1404 
1405  Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
1406  MDNode *FPMD = nullptr) {
1407  if (IsFPConstrained)
1408  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1409  L, R, nullptr, Name, FPMD);
1410 
1411  if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
1412  Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1413  return Insert(I, Name);
1414  }
1415 
1416  /// Copy fast-math-flags from an instruction rather than using the builder's
1417  /// default FMF.
1419  const Twine &Name = "") {
1420  if (IsFPConstrained)
1421  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1422  L, R, FMFSource, Name);
1423 
1424  if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
1425  Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
1426  FMFSource->getFastMathFlags());
1427  return Insert(I, Name);
1428  }
1429 
1430  Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
1431  MDNode *FPMD = nullptr) {
1432  if (IsFPConstrained)
1433  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1434  L, R, nullptr, Name, FPMD);
1435 
1436  if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
1437  Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1438  return Insert(I, Name);
1439  }
1440 
1441  /// Copy fast-math-flags from an instruction rather than using the builder's
1442  /// default FMF.
1444  const Twine &Name = "") {
1445  if (IsFPConstrained)
1446  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1447  L, R, FMFSource, Name);
1448 
1449  if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
1450  Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
1451  FMFSource->getFastMathFlags());
1452  return Insert(I, Name);
1453  }
1454 
1455  Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
1456  MDNode *FPMD = nullptr) {
1457  if (IsFPConstrained)
1458  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1459  L, R, nullptr, Name, FPMD);
1460 
1461  if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
1462  Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1463  return Insert(I, Name);
1464  }
1465 
1466  /// Copy fast-math-flags from an instruction rather than using the builder's
1467  /// default FMF.
1469  const Twine &Name = "") {
1470  if (IsFPConstrained)
1471  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1472  L, R, FMFSource, Name);
1473 
1474  if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
1475  Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
1476  FMFSource->getFastMathFlags());
1477  return Insert(I, Name);
1478  }
1479 
1480  Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
1481  MDNode *FPMD = nullptr) {
1482  if (IsFPConstrained)
1483  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1484  L, R, nullptr, Name, FPMD);
1485 
1486  if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
1487  Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1488  return Insert(I, Name);
1489  }
1490 
1491  /// Copy fast-math-flags from an instruction rather than using the builder's
1492  /// default FMF.
1494  const Twine &Name = "") {
1495  if (IsFPConstrained)
1496  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1497  L, R, FMFSource, Name);
1498 
1499  if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
1500  Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr,
1501  FMFSource->getFastMathFlags());
1502  return Insert(I, Name);
1503  }
1504 
1505  Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
1506  MDNode *FPMD = nullptr) {
1507  if (IsFPConstrained)
1508  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1509  L, R, nullptr, Name, FPMD);
1510 
1511  if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1512  Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1513  return Insert(I, Name);
1514  }
1515 
1516  /// Copy fast-math-flags from an instruction rather than using the builder's
1517  /// default FMF.
1519  const Twine &Name = "") {
1520  if (IsFPConstrained)
1521  return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1522  L, R, FMFSource, Name);
1523 
1524  if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1525  Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
1526  FMFSource->getFastMathFlags());
1527  return Insert(I, Name);
1528  }
1529 
1531  Value *LHS, Value *RHS, const Twine &Name = "",
1532  MDNode *FPMathTag = nullptr) {
1533  if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
1534  Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1535  if (isa<FPMathOperator>(BinOp))
1536  setFPAttrs(BinOp, FPMathTag, FMF);
1537  return Insert(BinOp, Name);
1538  }
1539 
1540  Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1541  assert(Cond2->getType()->isIntOrIntVectorTy(1));
1542  return CreateSelect(Cond1, Cond2,
1544  }
1545 
1546  Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
1547  assert(Cond2->getType()->isIntOrIntVectorTy(1));
1548  return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
1549  Cond2, Name);
1550  }
1551 
1553  Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1554  const Twine &Name = "", MDNode *FPMathTag = nullptr,
1557 
1558  Value *CreateNeg(Value *V, const Twine &Name = "",
1559  bool HasNUW = false, bool HasNSW = false) {
1560  if (auto *VC = dyn_cast<Constant>(V))
1561  return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1563  if (HasNUW) BO->setHasNoUnsignedWrap();
1564  if (HasNSW) BO->setHasNoSignedWrap();
1565  return BO;
1566  }
1567 
1568  Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1569  return CreateNeg(V, Name, false, true);
1570  }
1571 
1572  Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
1573  return CreateNeg(V, Name, true, false);
1574  }
1575 
1576  Value *CreateFNeg(Value *V, const Twine &Name = "",
1577  MDNode *FPMathTag = nullptr) {
1578  if (auto *VC = dyn_cast<Constant>(V))
1579  return Insert(Folder.CreateFNeg(VC), Name);
1580  return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
1581  Name);
1582  }
1583 
1584  /// Copy fast-math-flags from an instruction rather than using the builder's
1585  /// default FMF.
1587  const Twine &Name = "") {
1588  if (auto *VC = dyn_cast<Constant>(V))
1589  return Insert(Folder.CreateFNeg(VC), Name);
1590  return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
1591  FMFSource->getFastMathFlags()),
1592  Name);
1593  }
1594 
1595  Value *CreateNot(Value *V, const Twine &Name = "") {
1596  if (auto *VC = dyn_cast<Constant>(V))
1597  return Insert(Folder.CreateNot(VC), Name);
1599  }
1600 
1602  Value *V, const Twine &Name = "",
1603  MDNode *FPMathTag = nullptr) {
1604  if (auto *VC = dyn_cast<Constant>(V))
1605  return Insert(Folder.CreateUnOp(Opc, VC), Name);
1606  Instruction *UnOp = UnaryOperator::Create(Opc, V);
1607  if (isa<FPMathOperator>(UnOp))
1608  setFPAttrs(UnOp, FPMathTag, FMF);
1609  return Insert(UnOp, Name);
1610  }
1611 
1612  /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1613  /// Correct number of operands must be passed accordingly.
1614  Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1615  const Twine &Name = "", MDNode *FPMathTag = nullptr);
1616 
1617  //===--------------------------------------------------------------------===//
1618  // Instruction creation methods: Memory Instructions
1619  //===--------------------------------------------------------------------===//
1620 
1621  AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1622  Value *ArraySize = nullptr, const Twine &Name = "") {
1623  const DataLayout &DL = BB->getModule()->getDataLayout();
1624  Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1625  return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1626  }
1627 
1628  AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1629  const Twine &Name = "") {
1630  const DataLayout &DL = BB->getModule()->getDataLayout();
1631  Align AllocaAlign = DL.getPrefTypeAlign(Ty);
1632  unsigned AddrSpace = DL.getAllocaAddrSpace();
1633  return Insert(new AllocaInst(Ty, AddrSpace, ArraySize, AllocaAlign), Name);
1634  }
1635 
1636  /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1637  /// converting the string to 'bool' for the isVolatile parameter.
1638  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1639  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1640  }
1641 
1642  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1643  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), Name);
1644  }
1645 
1646  LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1647  const Twine &Name = "") {
1648  return CreateAlignedLoad(Ty, Ptr, MaybeAlign(), isVolatile, Name);
1649  }
1650 
1651  // Deprecated [opaque pointer types]
1653  const char *Name),
1654  "Use the version that explicitly specifies the "
1655  "loaded type instead") {
1656  return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1657  }
1658 
1659  // Deprecated [opaque pointer types]
1661  const Twine &Name = ""),
1662  "Use the version that explicitly specifies the "
1663  "loaded type instead") {
1664  return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1665  }
1666 
1667  // Deprecated [opaque pointer types]
1669  bool isVolatile,
1670  const Twine &Name = ""),
1671  "Use the version that explicitly specifies the "
1672  "loaded type instead") {
1673  return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile,
1674  Name);
1675  }
1676 
1677  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1678  return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
1679  }
1680 
1682  const char *Name) {
1683  return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1684  }
1685 
1687  const Twine &Name = "") {
1688  return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
1689  }
1690 
1692  bool isVolatile, const Twine &Name = "") {
1693  if (!Align) {
1694  const DataLayout &DL = BB->getModule()->getDataLayout();
1695  Align = DL.getABITypeAlign(Ty);
1696  }
1697  return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
1698  }
1699 
1700  // Deprecated [opaque pointer types]
1702  MaybeAlign Align,
1703  const char *Name),
1704  "Use the version that explicitly specifies the "
1705  "loaded type instead") {
1706  return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1707  Align, Name);
1708  }
1709  // Deprecated [opaque pointer types]
1711  MaybeAlign Align,
1712  const Twine &Name = ""),
1713  "Use the version that explicitly specifies the "
1714  "loaded type instead") {
1715  return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1716  Align, Name);
1717  }
1718  // Deprecated [opaque pointer types]
1720  MaybeAlign Align,
1721  bool isVolatile,
1722  const Twine &Name = ""),
1723  "Use the version that explicitly specifies the "
1724  "loaded type instead") {
1725  return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1726  Align, isVolatile, Name);
1727  }
1728 
1730  bool isVolatile = false) {
1731  if (!Align) {
1732  const DataLayout &DL = BB->getModule()->getDataLayout();
1733  Align = DL.getABITypeAlign(Val->getType());
1734  }
1735  return Insert(new StoreInst(Val, Ptr, isVolatile, *Align));
1736  }
1739  const Twine &Name = "") {
1740  return Insert(new FenceInst(Context, Ordering, SSID), Name);
1741  }
1742 
1745  AtomicOrdering SuccessOrdering,
1746  AtomicOrdering FailureOrdering,
1748  if (!Align) {
1749  const DataLayout &DL = BB->getModule()->getDataLayout();
1750  Align = llvm::Align(DL.getTypeStoreSize(New->getType()));
1751  }
1752 
1753  return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, *Align, SuccessOrdering,
1754  FailureOrdering, SSID));
1755  }
1756 
1758  Value *Val, MaybeAlign Align,
1759  AtomicOrdering Ordering,
1761  if (!Align) {
1762  const DataLayout &DL = BB->getModule()->getDataLayout();
1763  Align = llvm::Align(DL.getTypeStoreSize(Val->getType()));
1764  }
1765 
1766  return Insert(new AtomicRMWInst(Op, Ptr, Val, *Align, Ordering, SSID));
1767  }
1768 
1770  const Twine &Name = "") {
1771  return CreateGEP(nullptr, Ptr, IdxList, Name);
1772  }
1773 
1775  const Twine &Name = "") {
1776  if (auto *PC = dyn_cast<Constant>(Ptr)) {
1777  // Every index must be constant.
1778  size_t i, e;
1779  for (i = 0, e = IdxList.size(); i != e; ++i)
1780  if (!isa<Constant>(IdxList[i]))
1781  break;
1782  if (i == e)
1783  return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1784  }
1785  return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1786  }
1787 
1789  const Twine &Name = "") {
1790  return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1791  }
1792 
1794  const Twine &Name = "") {
1795  if (auto *PC = dyn_cast<Constant>(Ptr)) {
1796  // Every index must be constant.
1797  size_t i, e;
1798  for (i = 0, e = IdxList.size(); i != e; ++i)
1799  if (!isa<Constant>(IdxList[i]))
1800  break;
1801  if (i == e)
1802  return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1803  Name);
1804  }
1805  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1806  }
1807 
1808  Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1809  return CreateGEP(nullptr, Ptr, Idx, Name);
1810  }
1811 
1812  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1813  if (auto *PC = dyn_cast<Constant>(Ptr))
1814  if (auto *IC = dyn_cast<Constant>(Idx))
1815  return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1816  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1817  }
1818 
1820  const Twine &Name = "") {
1821  if (auto *PC = dyn_cast<Constant>(Ptr))
1822  if (auto *IC = dyn_cast<Constant>(Idx))
1823  return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1824  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1825  }
1826 
1827  Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
1828  return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
1829  }
1830 
1831  Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1832  const Twine &Name = "") {
1834 
1835  if (auto *PC = dyn_cast<Constant>(Ptr))
1836  return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1837 
1838  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1839  }
1840 
1841  Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1842  const Twine &Name = "") {
1844 
1845  if (auto *PC = dyn_cast<Constant>(Ptr))
1846  return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1847 
1848  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1849  }
1850 
1851  Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1852  const Twine &Name = "") {
1853  Value *Idxs[] = {
1856  };
1857 
1858  if (auto *PC = dyn_cast<Constant>(Ptr))
1859  return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1860 
1861  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1862  }
1863 
1864  Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1865  unsigned Idx1, const Twine &Name = "") {
1866  Value *Idxs[] = {
1869  };
1870 
1871  if (auto *PC = dyn_cast<Constant>(Ptr))
1872  return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1873 
1874  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1875  }
1876 
1877  Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1878  const Twine &Name = "") {
1880 
1881  if (auto *PC = dyn_cast<Constant>(Ptr))
1882  return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1883 
1884  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1885  }
1886 
1887  Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
1888  return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name);
1889  }
1890 
1891  Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1892  const Twine &Name = "") {
1894 
1895  if (auto *PC = dyn_cast<Constant>(Ptr))
1896  return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1897 
1898  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1899  }
1900 
1902  const Twine &Name = "") {
1903  return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name);
1904  }
1905 
1906  Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1907  const Twine &Name = "") {
1908  Value *Idxs[] = {
1911  };
1912 
1913  if (auto *PC = dyn_cast<Constant>(Ptr))
1914  return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1915 
1916  return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1917  }
1918 
1919  Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1920  const Twine &Name = "") {
1921  return CreateConstGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1922  }
1923 
1924  Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1925  uint64_t Idx1, const Twine &Name = "") {
1926  Value *Idxs[] = {
1929  };
1930 
1931  if (auto *PC = dyn_cast<Constant>(Ptr))
1932  return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1933 
1934  return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1935  }
1936 
1937  Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1938  const Twine &Name = "") {
1939  return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1940  }
1941 
1942  Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1943  const Twine &Name = "") {
1944  return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1945  }
1946 
1947  Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") {
1948  return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name);
1949  }
1950 
1951  /// Same as CreateGlobalString, but return a pointer with "i8*" type
1952  /// instead of a pointer to array of i8.
1953  ///
1954  /// If no module is given via \p M, it is take from the insertion point basic
1955  /// block.
1957  unsigned AddressSpace = 0,
1958  Module *M = nullptr) {
1961  Constant *Indices[] = {Zero, Zero};
1963  Indices);
1964  }
1965 
1966  //===--------------------------------------------------------------------===//
1967  // Instruction creation methods: Cast/Conversion Operators
1968  //===--------------------------------------------------------------------===//
1969 
1970  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1971  return CreateCast(Instruction::Trunc, V, DestTy, Name);
1972  }
1973 
1974  Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1975  return CreateCast(Instruction::ZExt, V, DestTy, Name);
1976  }
1977 
1978  Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
1979  return CreateCast(Instruction::SExt, V, DestTy, Name);
1980  }
1981 
1982  /// Create a ZExt or Trunc from the integer value V to DestTy. Return
1983  /// the value untouched if the type of V is already DestTy.
1985  const Twine &Name = "") {
1986  assert(V->getType()->isIntOrIntVectorTy() &&
1987  DestTy->isIntOrIntVectorTy() &&
1988  "Can only zero extend/truncate integers!");
1989  Type *VTy = V->getType();
1990  if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1991  return CreateZExt(V, DestTy, Name);
1992  if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1993  return CreateTrunc(V, DestTy, Name);
1994  return V;
1995  }
1996 
1997  /// Create a SExt or Trunc from the integer value V to DestTy. Return
1998  /// the value untouched if the type of V is already DestTy.
2000  const Twine &Name = "") {
2001  assert(V->getType()->isIntOrIntVectorTy() &&
2002  DestTy->isIntOrIntVectorTy() &&
2003  "Can only sign extend/truncate integers!");
2004  Type *VTy = V->getType();
2005  if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
2006  return CreateSExt(V, DestTy, Name);
2007  if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
2008  return CreateTrunc(V, DestTy, Name);
2009  return V;
2010  }
2011 
2012  Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
2013  if (IsFPConstrained)
2014  return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
2015  V, DestTy, nullptr, Name);
2016  return CreateCast(Instruction::FPToUI, V, DestTy, Name);
2017  }
2018 
2019  Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
2020  if (IsFPConstrained)
2021  return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
2022  V, DestTy, nullptr, Name);
2023  return CreateCast(Instruction::FPToSI, V, DestTy, Name);
2024  }
2025 
2026  Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
2027  if (IsFPConstrained)
2028  return CreateConstrainedFPCast(Intrinsic::experimental_constrained_uitofp,
2029  V, DestTy, nullptr, Name);
2030  return CreateCast(Instruction::UIToFP, V, DestTy, Name);
2031  }
2032 
2033  Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
2034  if (IsFPConstrained)
2035  return CreateConstrainedFPCast(Intrinsic::experimental_constrained_sitofp,
2036  V, DestTy, nullptr, Name);
2037  return CreateCast(Instruction::SIToFP, V, DestTy, Name);
2038  }
2039 
2041  const Twine &Name = "") {
2042  if (IsFPConstrained)
2043  return CreateConstrainedFPCast(
2044  Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
2045  Name);
2046  return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
2047  }
2048 
2049  Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
2050  if (IsFPConstrained)
2051  return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
2052  V, DestTy, nullptr, Name);
2053  return CreateCast(Instruction::FPExt, V, DestTy, Name);
2054  }
2055 
2057  const Twine &Name = "") {
2058  return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
2059  }
2060 
2062  const Twine &Name = "") {
2063  return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
2064  }
2065 
2067  const Twine &Name = "") {
2068  return CreateCast(Instruction::BitCast, V, DestTy, Name);
2069  }
2070 
2072  const Twine &Name = "") {
2073  return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
2074  }
2075 
2077  const Twine &Name = "") {
2078  if (V->getType() == DestTy)
2079  return V;
2080  if (auto *VC = dyn_cast<Constant>(V))
2081  return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
2082  return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
2083  }
2084 
2086  const Twine &Name = "") {
2087  if (V->getType() == DestTy)
2088  return V;
2089  if (auto *VC = dyn_cast<Constant>(V))
2090  return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
2091  return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
2092  }
2093 
2095  const Twine &Name = "") {
2096  if (V->getType() == DestTy)
2097  return V;
2098  if (auto *VC = dyn_cast<Constant>(V))
2099  return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
2100  return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
2101  }
2102 
2104  const Twine &Name = "") {
2105  if (V->getType() == DestTy)
2106  return V;
2107  if (auto *VC = dyn_cast<Constant>(V))
2108  return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
2109  return Insert(CastInst::Create(Op, V, DestTy), Name);
2110  }
2111 
2113  const Twine &Name = "") {
2114  if (V->getType() == DestTy)
2115  return V;
2116  if (auto *VC = dyn_cast<Constant>(V))
2117  return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
2118  return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
2119  }
2120 
2122  const Twine &Name = "") {
2123  if (V->getType() == DestTy)
2124  return V;
2125 
2126  if (auto *VC = dyn_cast<Constant>(V)) {
2128  Name);
2129  }
2130 
2132  Name);
2133  }
2134 
2135  Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
2136  const Twine &Name = "") {
2137  if (V->getType() == DestTy)
2138  return V;
2139  if (auto *VC = dyn_cast<Constant>(V))
2140  return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
2141  return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
2142  }
2143 
2145  const Twine &Name = "") {
2146  if (V->getType() == DestTy)
2147  return V;
2148  if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
2149  return CreatePtrToInt(V, DestTy, Name);
2150  if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
2151  return CreateIntToPtr(V, DestTy, Name);
2152 
2153  return CreateBitCast(V, DestTy, Name);
2154  }
2155 
2156  Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
2157  if (V->getType() == DestTy)
2158  return V;
2159  if (auto *VC = dyn_cast<Constant>(V))
2160  return Insert(Folder.CreateFPCast(VC, DestTy), Name);
2161  return Insert(CastInst::CreateFPCast(V, DestTy), Name);
2162  }
2163 
2165  Intrinsic::ID ID, Value *V, Type *DestTy,
2166  Instruction *FMFSource = nullptr, const Twine &Name = "",
2167  MDNode *FPMathTag = nullptr,
2170 
2171  // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
2172  // compile time error, instead of converting the string to bool for the
2173  // isSigned parameter.
2174  Value *CreateIntCast(Value *, Type *, const char *) = delete;
2175 
2176  //===--------------------------------------------------------------------===//
2177  // Instruction creation methods: Compare Instructions
2178  //===--------------------------------------------------------------------===//
2179 
2180  Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
2181  return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
2182  }
2183 
2184  Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
2185  return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
2186  }
2187 
2188  Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2189  return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
2190  }
2191 
2192  Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2193  return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
2194  }
2195 
2196  Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
2197  return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
2198  }
2199 
2200  Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
2201  return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
2202  }
2203 
2204  Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2205  return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
2206  }
2207 
2208  Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2209  return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
2210  }
2211 
2212  Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
2213  return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
2214  }
2215 
2216  Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
2217  return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
2218  }
2219 
2220  Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2221  MDNode *FPMathTag = nullptr) {
2222  return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
2223  }
2224 
2225  Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
2226  MDNode *FPMathTag = nullptr) {
2227  return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
2228  }
2229 
2230  Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
2231  MDNode *FPMathTag = nullptr) {
2232  return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
2233  }
2234 
2235  Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
2236  MDNode *FPMathTag = nullptr) {
2237  return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
2238  }
2239 
2240  Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
2241  MDNode *FPMathTag = nullptr) {
2242  return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
2243  }
2244 
2245  Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
2246  MDNode *FPMathTag = nullptr) {
2247  return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
2248  }
2249 
2250  Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
2251  MDNode *FPMathTag = nullptr) {
2252  return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
2253  }
2254 
2255  Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
2256  MDNode *FPMathTag = nullptr) {
2257  return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
2258  }
2259 
2260  Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2261  MDNode *FPMathTag = nullptr) {
2262  return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
2263  }
2264 
2265  Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
2266  MDNode *FPMathTag = nullptr) {
2267  return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
2268  }
2269 
2270  Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
2271  MDNode *FPMathTag = nullptr) {
2272  return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
2273  }
2274 
2275  Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
2276  MDNode *FPMathTag = nullptr) {
2277  return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
2278  }
2279 
2280  Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
2281  MDNode *FPMathTag = nullptr) {
2282  return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
2283  }
2284 
2285  Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
2286  MDNode *FPMathTag = nullptr) {
2287  return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
2288  }
2289 
2291  const Twine &Name = "") {
2292  if (auto *LC = dyn_cast<Constant>(LHS))
2293  if (auto *RC = dyn_cast<Constant>(RHS))
2294  return Insert(Folder.CreateICmp(P, LC, RC), Name);
2295  return Insert(new ICmpInst(P, LHS, RHS), Name);
2296  }
2297 
2298  // Create a quiet floating-point comparison (i.e. one that raises an FP
2299  // exception only in the case where an input is a signaling NaN).
2300  // Note that this differs from CreateFCmpS only if IsFPConstrained is true.
2302  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2303  return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
2304  }
2305 
2307  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2308  return CmpInst::isFPPredicate(Pred)
2309  ? CreateFCmp(Pred, LHS, RHS, Name, FPMathTag)
2310  : CreateICmp(Pred, LHS, RHS, Name);
2311  }
2312 
2313  // Create a signaling floating-point comparison (i.e. one that raises an FP
2314  // exception whenever an input is any NaN, signaling or quiet).
2315  // Note that this differs from CreateFCmp only if IsFPConstrained is true.
2317  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2318  return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
2319  }
2320 
2321 private:
2322  // Helper routine to create either a signaling or a quiet FP comparison.
2323  Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
2324  const Twine &Name, MDNode *FPMathTag,
2325  bool IsSignaling);
2326 
2327 public:
2330  const Twine &Name = "", Optional<fp::ExceptionBehavior> Except = None);
2331 
2332  //===--------------------------------------------------------------------===//
2333  // Instruction creation methods: Other Instructions
2334  //===--------------------------------------------------------------------===//
2335 
2336  PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
2337  const Twine &Name = "") {
2338  PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
2339  if (isa<FPMathOperator>(Phi))
2340  setFPAttrs(Phi, nullptr /* MDNode* */, FMF);
2341  return Insert(Phi, Name);
2342  }
2343 
2345  ArrayRef<Value *> Args = None, const Twine &Name = "",
2346  MDNode *FPMathTag = nullptr) {
2348  if (IsFPConstrained)
2350  if (isa<FPMathOperator>(CI))
2351  setFPAttrs(CI, FPMathTag, FMF);
2352  return Insert(CI, Name);
2353  }
2354 
2356  ArrayRef<OperandBundleDef> OpBundles,
2357  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2358  CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2359  if (IsFPConstrained)
2361  if (isa<FPMathOperator>(CI))
2362  setFPAttrs(CI, FPMathTag, FMF);
2363  return Insert(CI, Name);
2364  }
2365 
2367  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2368  return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
2369  FPMathTag);
2370  }
2371 
2373  ArrayRef<OperandBundleDef> OpBundles,
2374  const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2375  return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
2376  OpBundles, Name, FPMathTag);
2377  }
2378 
2380  Function *Callee, ArrayRef<Value *> Args, const Twine &Name = "",
2383 
2384  Value *CreateSelect(Value *C, Value *True, Value *False,
2385  const Twine &Name = "", Instruction *MDFrom = nullptr);
2386 
2387  VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
2388  return Insert(new VAArgInst(List, Ty), Name);
2389  }
2390 
2392  const Twine &Name = "") {
2393  if (auto *VC = dyn_cast<Constant>(Vec))
2394  if (auto *IC = dyn_cast<Constant>(Idx))
2395  return Insert(Folder.CreateExtractElement(VC, IC), Name);
2396  return Insert(ExtractElementInst::Create(Vec, Idx), Name);
2397  }
2398 
2399  Value *CreateExtractElement(Value *Vec, uint64_t Idx,
2400  const Twine &Name = "") {
2401  return CreateExtractElement(Vec, getInt64(Idx), Name);
2402  }
2403 
2405  const Twine &Name = "") {
2406  if (auto *VC = dyn_cast<Constant>(Vec))
2407  if (auto *NC = dyn_cast<Constant>(NewElt))
2408  if (auto *IC = dyn_cast<Constant>(Idx))
2409  return Insert(Folder.CreateInsertElement(VC, NC, IC), Name);
2410  return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
2411  }
2412 
2413  Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
2414  const Twine &Name = "") {
2415  return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
2416  }
2417 
2419  const Twine &Name = "") {
2420  SmallVector<int, 16> IntMask;
2421  ShuffleVectorInst::getShuffleMask(cast<Constant>(Mask), IntMask);
2422  return CreateShuffleVector(V1, V2, IntMask, Name);
2423  }
2424 
2427  const Twine &Name = ""),
2428  "Pass indices as 'int' instead") {
2429  SmallVector<int, 16> IntMask;
2430  IntMask.assign(Mask.begin(), Mask.end());
2431  return CreateShuffleVector(V1, V2, IntMask, Name);
2432  }
2433 
2434  /// See class ShuffleVectorInst for a description of the mask representation.
2436  const Twine &Name = "") {
2437  if (auto *V1C = dyn_cast<Constant>(V1))
2438  if (auto *V2C = dyn_cast<Constant>(V2))
2439  return Insert(Folder.CreateShuffleVector(V1C, V2C, Mask), Name);
2440  return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
2441  }
2442 
2443  /// Create a unary shuffle. The second vector operand of the IR instruction
2444  /// is poison.
2446  const Twine &Name = "") {
2448  }
2449 
2451  ArrayRef<unsigned> Idxs,
2452  const Twine &Name = "") {
2453  if (auto *AggC = dyn_cast<Constant>(Agg))
2454  return Insert(Folder.CreateExtractValue(AggC, Idxs), Name);
2455  return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
2456  }
2457 
2459  ArrayRef<unsigned> Idxs,
2460  const Twine &Name = "") {
2461  if (auto *AggC = dyn_cast<Constant>(Agg))
2462  if (auto *ValC = dyn_cast<Constant>(Val))
2463  return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
2464  return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
2465  }
2466 
2467  LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
2468  const Twine &Name = "") {
2469  return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
2470  }
2471 
2472  Value *CreateFreeze(Value *V, const Twine &Name = "") {
2473  return Insert(new FreezeInst(V), Name);
2474  }
2475 
2476  //===--------------------------------------------------------------------===//
2477  // Utility creation methods
2478  //===--------------------------------------------------------------------===//
2479 
2480  /// Return an i1 value testing if \p Arg is null.
2481  Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
2482  return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
2483  Name);
2484  }
2485 
2486  /// Return an i1 value testing if \p Arg is not null.
2488  return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
2489  Name);
2490  }
2491 
2492  /// Return the i64 difference between two pointer values, dividing out
2493  /// the size of the pointed-to objects.
2494  ///
2495  /// This is intended to implement C-style pointer subtraction. As such, the
2496  /// pointers must be appropriately aligned for their element types and
2497  /// pointing into the same object.
2498  Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "");
2499 
2500  /// Create a launder.invariant.group intrinsic call. If Ptr type is
2501  /// different from pointer to i8, it's casted to pointer to i8 in the same
2502  /// address space before call and casted back to Ptr type after call.
2504 
2505  /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
2506  /// different from pointer to i8, it's casted to pointer to i8 in the same
2507  /// address space before call and casted back to Ptr type after call.
2509 
2510  /// Return a vector value that contains the vector V reversed
2511  Value *CreateVectorReverse(Value *V, const Twine &Name = "");
2512 
2513  /// Return a vector value that contains \arg V broadcasted to \p
2514  /// NumElts elements.
2515  Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "");
2516 
2517  /// Return a vector value that contains \arg V broadcasted to \p
2518  /// EC elements.
2519  Value *CreateVectorSplat(ElementCount EC, Value *V, const Twine &Name = "");
2520 
2521  /// Return a value that has been extracted from a larger integer type.
2523  IntegerType *ExtractedTy, uint64_t Offset,
2524  const Twine &Name);
2525 
2527  unsigned Dimension, unsigned LastIndex,
2528  MDNode *DbgInfo);
2529 
2530  Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
2531  MDNode *DbgInfo);
2532 
2534  unsigned Index, unsigned FieldIndex,
2535  MDNode *DbgInfo);
2536 
2537 private:
2538  /// Helper function that creates an assume intrinsic call that
2539  /// represents an alignment assumption on the provided pointer \p PtrValue
2540  /// with offset \p OffsetValue and alignment value \p AlignValue.
2541  CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
2542  Value *PtrValue, Value *AlignValue,
2543  Value *OffsetValue);
2544 
2545 public:
2546  /// Create an assume intrinsic call that represents an alignment
2547  /// assumption on the provided pointer.
2548  ///
2549  /// An optional offset can be provided, and if it is provided, the offset
2550  /// must be subtracted from the provided pointer to get the pointer with the
2551  /// specified alignment.
2553  unsigned Alignment,
2554  Value *OffsetValue = nullptr);
2555 
2556  /// Create an assume intrinsic call that represents an alignment
2557  /// assumption on the provided pointer.
2558  ///
2559  /// An optional offset can be provided, and if it is provided, the offset
2560  /// must be subtracted from the provided pointer to get the pointer with the
2561  /// specified alignment.
2562  ///
2563  /// This overload handles the condition where the Alignment is dependent
2564  /// on an existing value rather than a static value.
2566  Value *Alignment,
2567  Value *OffsetValue = nullptr);
2568 };
2569 
2570 /// This provides a uniform API for creating instructions and inserting
2571 /// them into a basic block: either at the end of a BasicBlock, or at a specific
2572 /// iterator location in a block.
2573 ///
2574 /// Note that the builder does not expose the full generality of LLVM
2575 /// instructions. For access to extra instruction properties, use the mutators
2576 /// (e.g. setVolatile) on the instructions after they have been
2577 /// created. Convenience state exists to specify fast-math flags and fp-math
2578 /// tags.
2579 ///
2580 /// The first template argument specifies a class to use for creating constants.
2581 /// This defaults to creating minimally folded constants. The second template
2582 /// argument allows clients to specify custom insertion hooks that are called on
2583 /// every newly created insertion.
2584 template <typename FolderTy = ConstantFolder,
2585  typename InserterTy = IRBuilderDefaultInserter>
2586 class IRBuilder : public IRBuilderBase {
2587 private:
2588  FolderTy Folder;
2589  InserterTy Inserter;
2590 
2591 public:
2592  IRBuilder(LLVMContext &C, FolderTy Folder, InserterTy Inserter = InserterTy(),
2593  MDNode *FPMathTag = nullptr,
2594  ArrayRef<OperandBundleDef> OpBundles = None)
2595  : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles),
2596  Folder(Folder), Inserter(Inserter) {}
2597 
2598  explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
2599  ArrayRef<OperandBundleDef> OpBundles = None)
2600  : IRBuilderBase(C, this->Folder, this->Inserter, FPMathTag, OpBundles) {}
2601 
2602  explicit IRBuilder(BasicBlock *TheBB, FolderTy Folder,
2603  MDNode *FPMathTag = nullptr,
2604  ArrayRef<OperandBundleDef> OpBundles = None)
2605  : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2606  FPMathTag, OpBundles), Folder(Folder) {
2607  SetInsertPoint(TheBB);
2608  }
2609 
2610  explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
2611  ArrayRef<OperandBundleDef> OpBundles = None)
2612  : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2613  FPMathTag, OpBundles) {
2614  SetInsertPoint(TheBB);
2615  }
2616 
2617  explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
2618  ArrayRef<OperandBundleDef> OpBundles = None)
2619  : IRBuilderBase(IP->getContext(), this->Folder, this->Inserter,
2620  FPMathTag, OpBundles) {
2621  SetInsertPoint(IP);
2622  }
2623 
2624  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder,
2625  MDNode *FPMathTag = nullptr,
2626  ArrayRef<OperandBundleDef> OpBundles = None)
2627  : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2628  FPMathTag, OpBundles), Folder(Folder) {
2629  SetInsertPoint(TheBB, IP);
2630  }
2631 
2633  MDNode *FPMathTag = nullptr,
2634  ArrayRef<OperandBundleDef> OpBundles = None)
2635  : IRBuilderBase(TheBB->getContext(), this->Folder, this->Inserter,
2636  FPMathTag, OpBundles) {
2637  SetInsertPoint(TheBB, IP);
2638  }
2639 
2640  /// Avoid copying the full IRBuilder. Prefer using InsertPointGuard
2641  /// or FastMathFlagGuard instead.
2642  IRBuilder(const IRBuilder &) = delete;
2643 
2644  InserterTy &getInserter() { return Inserter; }
2645 };
2646 
2647 // Create wrappers for C Binding types (see CBindingWrapping.h).
2649 
2650 } // end namespace llvm
2651 
2652 #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:1924
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::IRBuilderBase::CreateXor
Value * CreateXor(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1401
i
i
Definition: README.txt:29
llvm::IRBuilderBase::CreateInBoundsGEP
Value * CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1793
llvm::EngineKind::Kind
Kind
Definition: ExecutionEngine.h:524
llvm::CmpInst::FCMP_ULE
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:737
llvm::IRBuilderBase::CreateIntMaxReduce
CallInst * CreateIntMaxReduce(Value *Src, bool IsSigned=false)
Create a vector integer max reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:388
llvm::IRBuilderBase::CreateFCmpUNE
Value * CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2285
llvm::IRBuilderBase::CreateIntCast
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
Definition: IRBuilder.h:2135
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:2592
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:210
llvm::IRBuilderBase::CreateStore
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1677
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:906
llvm::IRBuilder::getInserter
InserterTy & getInserter()
Definition: IRBuilder.h:2644
llvm::CatchSwitchInst::Create
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4234
llvm::IRBuilderBase::CreateICmpSGE
Value * CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2208
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:1006
llvm
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:3730
llvm::IRBuilderBase::CreateMulReduce
CallInst * CreateMulReduce(Value *Src)
Create a vector int mul reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:372
llvm::Type::getInt1Ty
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:194
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:3074
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:1540
llvm::IRBuilderBase::CreateConstInBoundsGEP2_32
Value * CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="")
Definition: IRBuilder.h:1864
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:743
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:2923
llvm::VAArgInst
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
Definition: Instructions.h:1810
llvm::IRBuilderBase::CreateAlignedStore
StoreInst * CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, bool isVolatile=false)
Definition: IRBuilder.h:1729
llvm::IRBuilderBase::CreateConstGEP1_64
Value * CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1877
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::Instruction::UnaryOps
UnaryOps
Definition: Instruction.h:761
llvm::IRBuilderBase::CreateExtractValue
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2450
llvm::IRBuilderBase::CreateLifetimeEnd
CallInst * CreateLifetimeEnd(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.end intrinsic.
Definition: IRBuilder.cpp:424
llvm::Type::getInt8PtrTy
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:249
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:722
llvm::IRBuilderBase::CreateZExtOrBitCast
Value * CreateZExtOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2076
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:722
llvm::IRBuilderBase::CreateNUWNeg
Value * CreateNUWNeg(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1572
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::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:3612
llvm::Function
Definition: Function.h:61
llvm::IRBuilderBase::CreatePtrToInt
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2056
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:2605
llvm::IRBuilderBase::CreateVectorReverse
Value * CreateVectorReverse(Value *V, const Twine &Name="")
Return a vector value that contains the vector V reversed.
Definition: IRBuilder.cpp:1012
llvm::IRBuilderBase::CreateFCmpOEQ
Value * CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2220
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:1397
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:1701
llvm::IRBuilderBase::CreateXor
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1392
llvm::AtomicRMWInst::BinOp
BinOp
This enumeration lists the possible modifications atomicrmw can make.
Definition: Instructions.h:714
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:842
Types.h
llvm::LandingPadInst
The landingpad instruction holds all of the information necessary to generate correct exception handl...
Definition: Instructions.h:2822
llvm::SwitchInst::Create
static SwitchInst * Create(Value *Value, BasicBlock *Default, unsigned NumCases, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3339
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:730
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:909
llvm::IRBuilder
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2586
llvm::InsertValueInst::Create
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2469
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:2945
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:1674
llvm::IRBuilder::IRBuilder
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, FolderTy Folder, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=None)
Definition: IRBuilder.h:2624
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:744
llvm::IRBuilderBase::CreateStructGEP
Value * CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx, const Twine &Name="")
Definition: IRBuilder.h:1942
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:967
llvm::IRBuilderBase::CreateOr
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1366
llvm::IRBuilderBase::CreateFPExt
Value * CreateFPExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2049
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:781
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:461
llvm::IRBuilderBase::setConstrainedFPCallAttr
void setConstrainedFPCallAttr(CallBase *I)
Definition: IRBuilder.h:353
llvm::IRBuilderBase::CreateMaskedLoad
CallInst * CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Load intrinsic.
Definition: IRBuilder.cpp:487
llvm::IRBuilderBase::CreateStripInvariantGroup
Value * CreateStripInvariantGroup(Value *Ptr)
Create a strip.invariant.group intrinsic call.
Definition: IRBuilder.cpp:987
llvm::IRBuilderBase::CreatePreserveUnionAccessIndex
Value * CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex, MDNode *DbgInfo)
Definition: IRBuilder.cpp:1101
llvm::InsertElementInst::Create
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1928
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:749
llvm::ExtractElementInst::Create
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1863
llvm::IRBuilderBase::CreateCmp
Value * CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2306
llvm::IRBuilderBase::CreateMaxNum
CallInst * CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the maxnum intrinsic.
Definition: IRBuilder.h:886
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::IRBuilderBase::CreateShuffleVector
Value * CreateShuffleVector(Value *V1, Value *V2, Value *Mask, const Twine &Name="")
Definition: IRBuilder.h:2418
Module.h
llvm::IRBuilderBase::CreateLogicalOr
Value * CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name="")
Definition: IRBuilder.h:1546
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:1094
llvm::IRBuilderBase::CreateTruncOrBitCast
Value * CreateTruncOrBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2094
llvm::GetElementPtrInst::CreateInBounds
static GetElementPtrInst * CreateInBounds(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Definition: Instructions.h:965
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:1430
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:120
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:789
llvm::Optional
Definition: APInt.h:33
llvm::IRBuilderBase::CreateInsertElement
Value * CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2413
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:2019
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:1576
Operator.h
llvm::IRBuilderBase::CreateStructGEP
Value * CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name="")
Definition: IRBuilder.h:1947
llvm::CmpInst::ICMP_SLE
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:752
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:827
llvm::Instruction::copyMetadata
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Definition: Instruction.cpp:800
llvm::ConstantExpr::getInBoundsGetElementPtr
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList)
Create an "inbounds" getelementptr.
Definition: Constants.h:1232
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:1011
llvm::IRBuilderBase::CreateCall
CallInst * CreateCall(FunctionCallee Callee, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > OpBundles, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2372
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:3111
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:1681
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:3700
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:2565
llvm::FastMathFlags
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:160
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:1956
llvm::IRBuilderBase::CreateInBoundsGEP
Value * CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:1819
llvm::IRBuilderBase::CreateCondBr
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, Instruction *MDSrc)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:982
llvm::IRBuilderBase::CreateAShr
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1320
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:950
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:3938
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:726
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:195
llvm::IRBuilderBase::CreateICmpSGT
Value * CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2204
llvm::IRBuilderBase::CreateAlloca
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1621
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:197
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:2355
llvm::IRBuilderBase::CreateIntToPtr
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2061
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:158
llvm::IRBuilderBase::CreateInvoke
InvokeInst * CreateInvoke(FunctionType *Ty, Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value * > Args=None, const Twine &Name="")
Definition: IRBuilder.h:1022
llvm::IRBuilderBase::CreateInvariantStart
CallInst * CreateInvariantStart(Value *Ptr, ConstantInt *Size=nullptr)
Create a call to invariant.start intrinsic.
Definition: IRBuilder.cpp:440
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:1033
llvm::IRBuilderBase::CreateGEP
Value * CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:1812
llvm::IRBuilderBase::CreateAlloca
AllocaInst * CreateAlloca(Type *Ty, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1628
llvm::IRBuilderBase::CreateAShr
Value * CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1330
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:1744
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:1530
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:1315
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:286
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:736
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:303
llvm::IRBuilderBase::CreateShl
Value * CreateShl(Value *LHS, uint64_t RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1294
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:205
llvm::IRBuilderBase::CreateNUWSub
Value * CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1220
llvm::IRBuilderBase::CreateFCmpULE
Value * CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2280
Instruction.h
llvm::IRBuilderBase::CreateCast
Value * CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2103
llvm::IRBuilderBase::CreateInsertValue
Value * CreateInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2458
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:808
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:1455
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:77
llvm::IRBuilder::IRBuilder
IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=None)
Definition: IRBuilder.h:2632
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:1224
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:2435
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:1251
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:1468
llvm::IRBuilderBase::CreateUIToFP
Value * CreateUIToFP(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2026
llvm::AArch64CC::VC
@ VC
Definition: AArch64BaseInfo.h:243
llvm::IRBuilderBase::CreateNSWAdd
Value * CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1199
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:228
llvm::CmpInst::isFPPredicate
bool isFPPredicate() const
Definition: InstrTypes.h:816
Constants.h
llvm::IRBuilderBase::CreateGEP
Value * CreateGEP(Value *Ptr, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:1808
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:1443
llvm::IRBuilder::IRBuilder
IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=None)
Definition: IRBuilder.h:2610
llvm::IRBuilderDefaultInserter::~IRBuilderDefaultInserter
virtual ~IRBuilderDefaultInserter()
Definition: IRBuilder.cpp:1178
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:167
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:124
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:1891
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:185
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:748
llvm::IRBuilderBase::CreateLShr
Value * CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1310
llvm::IRBuilderBase::CreateCallBr
CallBrInst * CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args=None, const Twine &Name="")
Definition: IRBuilder.h:1069
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:4561
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:1638
llvm::IRBuilderBase::CreateExactSDiv
Value * CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1265
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:1493
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:2598
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:735
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:1601
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:3139
llvm::IRBuilderBase::CreateAlignedLoad
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, bool isVolatile, const Twine &Name="")
Definition: IRBuilder.h:1691
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:119
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:782
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:1120
llvm::IRBuilderBase::CreateFCmpUGE
Value * CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2270
llvm::IRBuilderBase::CreateShuffleVector
Value * CreateShuffleVector(Value *V, ArrayRef< int > Mask, const Twine &Name="")
Create a unary shuffle.
Definition: IRBuilder.h:2445
llvm::CmpInst::FCMP_UNO
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:732
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:147
llvm::IRBuilderBase::CreateXorReduce
CallInst * CreateXorReduce(Value *Src)
Create a vector int XOR reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:384
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:3005
llvm::IRBuilderBase::CreateInsertElement
Value * CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2404
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:1770
llvm::IRBuilder::IRBuilder
IRBuilder(BasicBlock *TheBB, FolderTy Folder, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=None)
Definition: IRBuilder.h:2602
llvm::IRBuilderBase::CreateFCmp
Value * CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2301
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:885
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:725
DebugLoc.h
llvm::IRBuilderBase::CreateConstInBoundsGEP1_32
Value * CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, const Twine &Name="")
Definition: IRBuilder.h:1841
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:728
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:144
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:400
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:3021
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:1384
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:1354
llvm::CatchReturnInst::Create
static CatchReturnInst * Create(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4475
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:1041
llvm::IRBuilderBase::CreateRet
ReturnInst * CreateRet(Value *V)
Create a 'ret <val>' instruction.
Definition: IRBuilder.h:948
Type.h
llvm::IRBuilderBase::CreateAddrSpaceCast
Value * CreateAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2071
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:1340
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:1269
llvm::IRBuilderBase::CreatePointerCast
Value * CreatePointerCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2112
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:277
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:2012
llvm::maxnum
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE maxNum semantics.
Definition: APFloat.h:1297
llvm::IRBuilderBase::CreateLifetimeStart
CallInst * CreateLifetimeStart(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.start intrinsic.
Definition: IRBuilder.cpp:408
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:724
llvm::IRBuilderBase::CreateLaunderInvariantGroup
Value * CreateLaunderInvariantGroup(Value *Ptr)
Create a launder.invariant.group intrinsic call.
Definition: IRBuilder.cpp:963
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3686
llvm::IRBuilderBase::CreateAShr
Value * CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1335
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:959
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:1974
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:1101
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:1405
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:2230
llvm::IRBuilderBase::CreateFDiv
Value * CreateFDiv(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1480
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:1203
llvm::CleanupPadInst
Definition: Instructions.h:4369
llvm::IRBuilderBase::CreateBitCast
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2066
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:303
llvm::IRBuilderBase::CreateConstInBoundsGEP2_64
Value * CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1937
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:1418
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::CreateMaximum
CallInst * CreateMaximum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the maximum intrinsic.
Definition: IRBuilder.h:896
llvm::IRBuilderBase::CreateICmp
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2290
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:1178
llvm::ResumeInst::Create
static ResumeInst * Create(Value *Exn, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4149
llvm::IRBuilderBase::CreatePreserveArrayAccessIndex
Value * CreatePreserveArrayAccessIndex(Type *ElTy, Value *Base, unsigned Dimension, unsigned LastIndex, MDNode *DbgInfo)
Definition: IRBuilder.cpp:1073
llvm::IRBuilderBase::CreateOr
Value * CreateOr(Value *LHS, uint64_t RHS, const Twine &Name="")
Definition: IRBuilder.h:1380
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:2344
llvm::IRBuilderFolder::CreateICmp
virtual Value * CreateICmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const =0
llvm::CatchReturnInst
Definition: Instructions.h:4461
llvm::IRBuilderBase::CreateNeg
Value * CreateNeg(Value *V, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1558
llvm::IRBuilderBase::CreateCall
CallInst * CreateCall(FunctionCallee Callee, ArrayRef< Value * > Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2366
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
llvm::IRBuilderBase::CreateResume
ResumeInst * CreateResume(Value *Exn)
Definition: IRBuilder.h:1085
llvm::IRBuilderBase::CreateConstGEP2_32
Value * CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1, const Twine &Name="")
Definition: IRBuilder.h:1851
llvm::IRBuilderBase::setDefaultOperandBundles
void setDefaultOperandBundles(ArrayRef< OperandBundleDef > OpBundles)
Definition: IRBuilder.h:357
llvm::IRBuilderBase::CreateInBoundsGEP
Value * CreateInBoundsGEP(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1788
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:3895
llvm::IRBuilderBase::CreateSDiv
Value * CreateSDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1255
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:1216
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::BranchInst::Create
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3061
llvm::SyncScope::ID
uint8_t ID
Definition: LLVMContext.h:47
llvm::IRBuilderBase::CreateCatchRet
CatchReturnInst * CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB)
Definition: IRBuilder.h:1112
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:2425
llvm::IRBuilderBase::CreateMinimum
CallInst * CreateMinimum(Value *LHS, Value *RHS, const Twine &Name="")
Create call to the minimum intrinsic.
Definition: IRBuilder.h:891
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:2487
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:932
llvm::IRBuilderBase::CreateFPMinReduce
CallInst * CreateFPMinReduce(Value *Src)
Create a vector float min reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:404
llvm::IRBuilderBase::CreateFPCast
Value * CreateFPCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2156
llvm::IRBuilderBase::CreateIntMinReduce
CallInst * CreateIntMinReduce(Value *Src, bool IsSigned=false)
Create a vector integer min reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:394
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:634
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:894
llvm::IRBuilderBase::CreateUnreachable
UnreachableInst * CreateUnreachable()
Definition: IRBuilder.h:1116
llvm::IRBuilderBase::CreateAdd
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:1190
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:467
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 vector fmul reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:360
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:1563
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:1710
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:1719
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:727
llvm::IRBuilderBase::CreateSIToFP
Value * CreateSIToFP(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2033
llvm::IRBuilderBase::CreateFence
FenceInst * CreateFence(AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System, const Twine &Name="")
Definition: IRBuilder.h:1737
llvm::IRBuilderBase::CreateConstGEP2_64
Value * CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1919
llvm::CmpInst::ICMP_UGE
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:746
llvm::IRBuilderBase::CreateExtractElement
Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:2391
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:1586
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:753
llvm::IRBuilderBase::CreateLandingPad
LandingPadInst * CreateLandingPad(Type *Ty, unsigned NumClauses, const Twine &Name="")
Definition: IRBuilder.h:2467
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::IRBuilderBase::CreateLoad
LoadInst * CreateLoad(Type *Ty, Value *Ptr, bool isVolatile, const Twine &Name="")
Definition: IRBuilder.h:1646
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:798
llvm::IRBuilderBase::CreateAndReduce
CallInst * CreateAndReduce(Value *Src)
Create a vector int AND reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:376
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:897
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:2216
llvm::IRBuilderBase::InsertPoint::InsertPoint
InsertPoint()=default
Creates a new insertion point which doesn't point to anything.
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:649
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:70
llvm::IRBuilderBase::CreateAnd
Value * CreateAnd(ArrayRef< Value * > Ops)
Definition: IRBuilder.h:1358
llvm::IRBuilderBase::CreateNoAliasScopeDeclaration
Instruction * CreateNoAliasScopeDeclaration(Value *Scope)
Create a llvm.experimental.noalias.scope.decl intrinsic call.
Definition: IRBuilder.cpp:472
llvm::CmpInst::ICMP_SLT
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:751
llvm::GetElementPtrInst::Create
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:931
llvm::IRBuilderBase::CreatePHI
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Definition: IRBuilder.h:2336
llvm::IRBuilderBase::CreateICmpSLT
Value * CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2212
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:259
llvm::BinaryOperator
Definition: InstrTypes.h:190
llvm::IRBuilderBase::IsFPConstrained
bool IsFPConstrained
Definition: IRBuilder.h:129
None.h
DataLayout.h
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:167
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
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:747
llvm::IRBuilderBase::CreateSRem
Value * CreateSRem(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1274
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:2180
llvm::IRBuilderBase::CreateConstGEP1_32
Value * CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name="")
Definition: IRBuilder.h:1827
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:1668
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:4383
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:232
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:570
llvm::IRBuilderBase::CreateICmpUGE
Value * CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2192
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:973
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:1493
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:174
ValueHandle.h
llvm::Type::getInt128Ty
static IntegerType * getInt128Ty(LLVMContext &C)
Definition: Type.cpp:199
llvm::IRBuilderBase::CreateConstGEP1_32
Value * CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, const Twine &Name="")
Definition: IRBuilder.h:1831
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:702
llvm::IRBuilderBase::CreateGEP
Value * CreateGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1774
llvm::ConstantInt::getFalse
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:840
llvm::IRBuilderBase::BB
BasicBlock * BB
Definition: IRBuilder.h:120
llvm::IRBuilderBase::CreateTrunc
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1970
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:1652
llvm::RoundingModeToStr
Optional< StringRef > RoundingModeToStr(RoundingMode)
For any RoundingMode enumerator, returns a string valid as input in constrained intrinsic rounding mo...
Definition: FPEnv.cpp:33
llvm::IRBuilderBase::CreateAddReduce
CallInst * CreateAddReduce(Value *Src)
Create a vector int add reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:368
llvm::IRBuilderBase::CreateCleanupRet
CleanupReturnInst * CreateCleanupRet(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB=nullptr)
Definition: IRBuilder.h:1089
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:205
llvm::IRBuilderBase::CreateFCmpONE
Value * CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2245
llvm::FastMathFlags::clear
void clear()
Definition: Operator.h:201
llvm::IRBuilderBase::CreateFCmpOLE
Value * CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2240
llvm::IRBuilderBase::CreatePointerBitCastOrAddrSpaceCast
Value * CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2121
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:734
llvm::IRBuilderFolder::CreateUDiv
virtual Value * CreateUDiv(Constant *LHS, Constant *RHS, bool isExact=false) const =0
llvm::IRBuilderBase::CreateConstGEP1_64
Value * CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1887
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:4136
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
llvm::minnum
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
Definition: APFloat.h:1286
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:198
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:2144
llvm::ConstantInt::getTrue
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:833
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:347
llvm::Type::getIntNTy
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Definition: Type.cpp:201
llvm::IRBuilderBase::CreateIsNull
Value * CreateIsNull(Value *Arg, const Twine &Name="")
Return an i1 value testing if Arg is null.
Definition: IRBuilder.h:2481
uint16_t
llvm::Type::getHalfTy
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:182
llvm::IRBuilderBase::CreateFreeze
Value * CreateFreeze(Value *V, const Twine &Name="")
Definition: IRBuilder.h:2472
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:314
llvm::IRBuilderBase::CreateFCmpOLT
Value * CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2235
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:2612
llvm::IRBuilderBase::CreateICmpULT
Value * CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2196
llvm::IRBuilderBase::Insert
InstTy * Insert(InstTy *I, const Twine &Name="") const
Insert and return the specified instruction.
Definition: IRBuilder.h:149
llvm::IRBuilderBase::CreateMaskedGather
CallInst * CreateMaskedGather(Value *Ptrs, Align Alignment, Value *Mask=nullptr, Value *PassThru=nullptr, const Twine &Name="")
Create a call to Masked Gather intrinsic.
Definition: IRBuilder.cpp:539
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:208
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
llvm::IRBuilderBase::CreateConstInBoundsGEP1_64
Value * CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name="")
Definition: IRBuilder.h:1901
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:1999
Function.h
llvm::IRBuilderBase::CreateFPTrunc
Value * CreateFPTrunc(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:2040
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:2950
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:1642
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 vector fadd reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:352
llvm::CmpInst::ICMP_SGE
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:750
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:184
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:183
llvm::CleanupReturnInst
Definition: Instructions.h:4542
llvm::IRBuilderBase::CreateNUWMul
Value * CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1237
llvm::IndirectBrInst
Indirect Branch Instruction.
Definition: Instructions.h:3551
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:474
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:881
llvm::CatchPadInst
Definition: Instructions.h:4410
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:1288
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:1050
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:389
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:768
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:180
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:1978
llvm::ShuffleVectorInst::getShuffleMask
ArrayRef< int > getShuffleMask() const
Definition: Instructions.h:2056
llvm::ShuffleVectorInst
This instruction constructs a fixed permutation of two input vectors.
Definition: Instructions.h:1986
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:2420
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:667
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:1076
llvm::IRBuilderBase::InsertPoint::getPoint
BasicBlock::iterator getPoint() const
Definition: IRBuilder.h:267
llvm::IRBuilderBase::CreateMemCpyInline
CallInst * CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size)
Definition: IRBuilder.cpp:204
llvm::IRBuilderBase::CreateExtractElement
Value * CreateExtractElement(Value *Vec, uint64_t Idx, const Twine &Name="")
Definition: IRBuilder.h:2399
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:1376
llvm::IRBuilderBase::CreateLShr
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Definition: IRBuilder.h:1300
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:745
llvm::IRBuilderBase::CreateAtomicRMW
AtomicRMWInst * CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val, MaybeAlign Align, AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Definition: IRBuilder.h:1757
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:738
llvm::Type::getPointerElementType
Type * getPointerElementType() const
Definition: Type.h:378
llvm::IRBuilderBase::CreateFCmpUNO
Value * CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2255
llvm::IRBuilderBase::CreateMaskedStore
CallInst * CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment, Value *Mask)
Create a call to Masked Store intrinsic.
Definition: IRBuilder.cpp:508
llvm::FreezeInst
This class represents a freeze function that returns random concrete value if an operand is either a ...
Definition: Instructions.h:5287
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::SyncScope::System
@ System
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:58
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:1279
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:1660
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
llvm::IRBuilderBase::CreateRetVoid
ReturnInst * CreateRetVoid()
Create a 'ret void' instruction.
Definition: IRBuilder.h:943
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:1058
llvm::IRBuilderCallbackInserter::~IRBuilderCallbackInserter
virtual ~IRBuilderCallbackInserter()
Definition: IRBuilder.cpp:1179
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:164
llvm::IRBuilderBase::CreateFCmpUEQ
Value * CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2260
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:765
llvm::PHINode
Definition: Instructions.h:2572
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:1050
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:1984
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:729
llvm::IRBuilderBase::CreateFCmpUGT
Value * CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2265
llvm::IRBuilderBase::CreateCleanupPad
CleanupPadInst * CreateCleanupPad(Value *ParentPad, ArrayRef< Value * > Args=None, const Twine &Name="")
Definition: IRBuilder.h:1106
llvm::IRBuilderBase::CreateFCmpS
Value * CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2316
llvm::IRBuilderBase::CreateNot
Value * CreateNot(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1595
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:1518
llvm::Type::getInt16Ty
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:196
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1164
llvm::IRBuilderBase::CreateVectorSplat
Value * CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name="")
Return a vector value that contains.
Definition: IRBuilder.cpp:1028
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:94
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:397
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:1906
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:273
llvm::IRBuilderBase::CreateNSWNeg
Value * CreateNSWNeg(Value *V, const Twine &Name="")
Definition: IRBuilder.h:1568
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:996
llvm::IRBuilderBase::CreateFRem
Value * CreateFRem(Value *L, Value *R, const Twine &Name="", MDNode *FPMD=nullptr)
Definition: IRBuilder.h:1505
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1450
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:2188
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:1241
llvm::UnreachableInst
This function has undefined behavior.
Definition: Instructions.h:4650
llvm::IRBuilderBase::CreateNoAliasScopeDeclaration
Instruction * CreateNoAliasScopeDeclaration(MDNode *ScopeTag)
Definition: IRBuilder.h:778
llvm::IRBuilderBase::CreateICmpNE
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2184
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:3037
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:1207
llvm::SwitchInst
Multiway switch.
Definition: Instructions.h:3149
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:2085
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:61
llvm::IRBuilder::IRBuilder
IRBuilder(Instruction *IP, MDNode *FPMathTag=nullptr, ArrayRef< OperandBundleDef > OpBundles=None)
Definition: IRBuilder.h:2617
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:2989
llvm::IRBuilderBase::CreateFCmpORD
Value * CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2250
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3005
llvm::IRBuilderBase::CreateVAArg
VAArgInst * CreateVAArg(Value *List, Type *Ty, const Twine &Name="")
Definition: IRBuilder.h:2387
llvm::AMDGPU::VGPRIndexMode::Id
Id
Definition: SIDefines.h:221
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:2549
llvm::IRBuilderBase::CreateGEP
Value * CreateGEP(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1769
llvm::IRBuilderBase::CreateFCmpOGT
Value * CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2225
llvm::CmpInst::FCMP_TRUE
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:739
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:901
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:1156
llvm::CatchPadInst::Create
static CatchPadInst * Create(Value *CatchSwitch, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4424
llvm::IRBuilderBase::CreateICmpULE
Value * CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2200
Value.h
llvm::CatchSwitchInst
Definition: Instructions.h:4193
llvm::IRBuilderBase::CreateFCmpULT
Value * CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2275
llvm::IRBuilderFolder::CreateAnd
virtual Value * CreateAnd(Constant *LHS, Constant *RHS) const =0
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:522
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:667
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:1686
llvm::IRBuilderBase::CreateOrReduce
CallInst * CreateOrReduce(Value *Src)
Create a vector int OR reduction intrinsic of the source vector.
Definition: IRBuilder.cpp:380
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:184
llvm::IRBuilderBase::CreateCall
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2344
llvm::CmpInst::FCMP_ORD
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:731
llvm::IRBuilderBase::CreateAnd
Value * CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name="")
Definition: IRBuilder.h:1350
llvm::IRBuilderBase::OperandBundlesGuard
Definition: IRBuilder.h:418
llvm::IRBuilderFolder::CreateOr
virtual Value * CreateOr(Constant *LHS, Constant *RHS) const =0
llvm::CmpInst::FCMP_UEQ
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:733
llvm::IRBuilderBase::CreateNSWMul
Value * CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1233
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:102
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:38
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:466
llvm::ExceptionBehaviorToStr
Optional< StringRef > ExceptionBehaviorToStr(fp::ExceptionBehavior)
For any ExceptionBehavior enumerator, returns a string valid as input in constrained intrinsic except...
Definition: FPEnv.cpp:68
llvm::PoisonValue::get
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1789
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