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