LLVM  4.0.0
InstrTypes.h
Go to the documentation of this file.
1 //===-- llvm/InstrTypes.h - Important Instruction subclasses ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines various meta classes of instructions that exist in the VM
11 // representation. Specific concrete subclasses of these may be found in the
12 // i*.h files...
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_IR_INSTRTYPES_H
17 #define LLVM_IR_INSTRTYPES_H
18 
19 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/None.h"
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/StringMap.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/Twine.h"
27 #include "llvm/IR/Attributes.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Instruction.h"
30 #include "llvm/IR/LLVMContext.h"
31 #include "llvm/IR/OperandTraits.h"
32 #include "llvm/IR/User.h"
33 #include "llvm/Support/Casting.h"
35 #include <algorithm>
36 #include <cassert>
37 #include <cstddef>
38 #include <cstdint>
39 #include <iterator>
40 #include <string>
41 #include <vector>
42 
43 namespace llvm {
44 
45 //===----------------------------------------------------------------------===//
46 // TerminatorInst Class
47 //===----------------------------------------------------------------------===//
48 
49 /// Subclasses of this class are all able to terminate a basic
50 /// block. Thus, these are all the flow control type of operations.
51 ///
52 class TerminatorInst : public Instruction {
53 protected:
55  Use *Ops, unsigned NumOps,
56  Instruction *InsertBefore = nullptr)
57  : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
58 
60  Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
61  : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
62 
63  // Out of line virtual method, so the vtable, etc has a home.
64  ~TerminatorInst() override;
65 
66  /// Virtual methods - Terminators should overload these and provide inline
67  /// overrides of non-V methods.
68  virtual BasicBlock *getSuccessorV(unsigned idx) const = 0;
69  virtual unsigned getNumSuccessorsV() const = 0;
70  virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0;
71 
72 public:
73  /// Return the number of successors that this terminator has.
74  unsigned getNumSuccessors() const {
75  return getNumSuccessorsV();
76  }
77 
78  /// Return the specified successor.
79  BasicBlock *getSuccessor(unsigned idx) const {
80  return getSuccessorV(idx);
81  }
82 
83  /// Update the specified successor to point at the provided block.
84  void setSuccessor(unsigned idx, BasicBlock *B) {
85  setSuccessorV(idx, B);
86  }
87 
88  // Methods for support type inquiry through isa, cast, and dyn_cast:
89  static inline bool classof(const Instruction *I) {
90  return I->isTerminator();
91  }
92  static inline bool classof(const Value *V) {
93  return isa<Instruction>(V) && classof(cast<Instruction>(V));
94  }
95 
96  // \brief Returns true if this terminator relates to exception handling.
97  bool isExceptional() const {
98  switch (getOpcode()) {
99  case Instruction::CatchSwitch:
100  case Instruction::CatchRet:
101  case Instruction::CleanupRet:
102  case Instruction::Invoke:
103  case Instruction::Resume:
104  return true;
105  default:
106  return false;
107  }
108  }
109 
110  //===--------------------------------------------------------------------===//
111  // succ_iterator definition
112  //===--------------------------------------------------------------------===//
113 
114  template <class Term, class BB> // Successor Iterator
115  class SuccIterator : public std::iterator<std::random_access_iterator_tag, BB,
116  int, BB *, BB *> {
117  typedef std::iterator<std::random_access_iterator_tag, BB, int, BB *, BB *>
118  super;
119 
120  public:
121  typedef typename super::pointer pointer;
122  typedef typename super::reference reference;
123 
124  private:
125  Term TermInst;
126  unsigned idx;
127  typedef SuccIterator<Term, BB> Self;
128 
129  inline bool index_is_valid(unsigned idx) {
130  return idx < TermInst->getNumSuccessors();
131  }
132 
133  /// \brief Proxy object to allow write access in operator[]
134  class SuccessorProxy {
135  Self it;
136 
137  public:
138  explicit SuccessorProxy(const Self &it) : it(it) {}
139 
140  SuccessorProxy(const SuccessorProxy &) = default;
141 
142  SuccessorProxy &operator=(SuccessorProxy r) {
143  *this = reference(r);
144  return *this;
145  }
146 
147  SuccessorProxy &operator=(reference r) {
148  it.TermInst->setSuccessor(it.idx, r);
149  return *this;
150  }
151 
152  operator reference() const { return *it; }
153  };
154 
155  public:
156  // begin iterator
157  explicit inline SuccIterator(Term T) : TermInst(T), idx(0) {}
158  // end iterator
159  inline SuccIterator(Term T, bool) : TermInst(T) {
160  if (TermInst)
161  idx = TermInst->getNumSuccessors();
162  else
163  // Term == NULL happens, if a basic block is not fully constructed and
164  // consequently getTerminator() returns NULL. In this case we construct
165  // a SuccIterator which describes a basic block that has zero
166  // successors.
167  // Defining SuccIterator for incomplete and malformed CFGs is especially
168  // useful for debugging.
169  idx = 0;
170  }
171 
172  /// This is used to interface between code that wants to
173  /// operate on terminator instructions directly.
174  unsigned getSuccessorIndex() const { return idx; }
175 
176  inline bool operator==(const Self &x) const { return idx == x.idx; }
177  inline bool operator!=(const Self &x) const { return !operator==(x); }
178 
179  inline reference operator*() const { return TermInst->getSuccessor(idx); }
180  inline pointer operator->() const { return operator*(); }
181 
182  inline Self &operator++() {
183  ++idx;
184  return *this;
185  } // Preincrement
186 
187  inline Self operator++(int) { // Postincrement
188  Self tmp = *this;
189  ++*this;
190  return tmp;
191  }
192 
193  inline Self &operator--() {
194  --idx;
195  return *this;
196  } // Predecrement
197  inline Self operator--(int) { // Postdecrement
198  Self tmp = *this;
199  --*this;
200  return tmp;
201  }
202 
203  inline bool operator<(const Self &x) const {
204  assert(TermInst == x.TermInst &&
205  "Cannot compare iterators of different blocks!");
206  return idx < x.idx;
207  }
208 
209  inline bool operator<=(const Self &x) const {
210  assert(TermInst == x.TermInst &&
211  "Cannot compare iterators of different blocks!");
212  return idx <= x.idx;
213  }
214  inline bool operator>=(const Self &x) const {
215  assert(TermInst == x.TermInst &&
216  "Cannot compare iterators of different blocks!");
217  return idx >= x.idx;
218  }
219 
220  inline bool operator>(const Self &x) const {
221  assert(TermInst == x.TermInst &&
222  "Cannot compare iterators of different blocks!");
223  return idx > x.idx;
224  }
225 
226  inline Self &operator+=(int Right) {
227  unsigned new_idx = idx + Right;
228  assert(index_is_valid(new_idx) && "Iterator index out of bound");
229  idx = new_idx;
230  return *this;
231  }
232 
233  inline Self operator+(int Right) const {
234  Self tmp = *this;
235  tmp += Right;
236  return tmp;
237  }
238 
239  inline Self &operator-=(int Right) { return operator+=(-Right); }
240 
241  inline Self operator-(int Right) const { return operator+(-Right); }
242 
243  inline int operator-(const Self &x) const {
244  assert(TermInst == x.TermInst &&
245  "Cannot work on iterators of different blocks!");
246  int distance = idx - x.idx;
247  return distance;
248  }
249 
250  inline SuccessorProxy operator[](int offset) {
251  Self tmp = *this;
252  tmp += offset;
253  return SuccessorProxy(tmp);
254  }
255 
256  /// Get the source BB of this iterator.
257  inline BB *getSource() {
258  assert(TermInst && "Source not available, if basic block was malformed");
259  return TermInst->getParent();
260  }
261  };
262 
268 
269 private:
270  inline succ_iterator succ_begin() { return succ_iterator(this); }
271  inline succ_const_iterator succ_begin() const {
272  return succ_const_iterator(this);
273  }
274  inline succ_iterator succ_end() { return succ_iterator(this, true); }
275  inline succ_const_iterator succ_end() const {
276  return succ_const_iterator(this, true);
277  }
278 
279 public:
281  return succ_range(succ_begin(), succ_end());
282  }
283  inline succ_const_range successors() const {
284  return succ_const_range(succ_begin(), succ_end());
285  }
286 };
287 
288 //===----------------------------------------------------------------------===//
289 // UnaryInstruction Class
290 //===----------------------------------------------------------------------===//
291 
293 protected:
294  UnaryInstruction(Type *Ty, unsigned iType, Value *V,
295  Instruction *IB = nullptr)
296  : Instruction(Ty, iType, &Op<0>(), 1, IB) {
297  Op<0>() = V;
298  }
299  UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
300  : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
301  Op<0>() = V;
302  }
303 
304 public:
305  // allocate space for exactly one operand
306  void *operator new(size_t s) {
307  return User::operator new(s, 1);
308  }
309 
310  void *operator new(size_t, unsigned) = delete;
311 
312  // Out of line virtual method, so the vtable, etc has a home.
313  ~UnaryInstruction() override;
314 
315  /// Transparently provide more efficient getOperand methods.
317 
318  // Methods for support type inquiry through isa, cast, and dyn_cast:
319  static inline bool classof(const Instruction *I) {
320  return I->getOpcode() == Instruction::Alloca ||
321  I->getOpcode() == Instruction::Load ||
322  I->getOpcode() == Instruction::VAArg ||
323  I->getOpcode() == Instruction::ExtractValue ||
324  (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
325  }
326  static inline bool classof(const Value *V) {
327  return isa<Instruction>(V) && classof(cast<Instruction>(V));
328  }
329 };
330 
331 template <>
333  public FixedNumOperandTraits<UnaryInstruction, 1> {
334 };
335 
337 
338 //===----------------------------------------------------------------------===//
339 // BinaryOperator Class
340 //===----------------------------------------------------------------------===//
341 
342 class BinaryOperator : public Instruction {
343 protected:
344  void init(BinaryOps iType);
345  BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
346  const Twine &Name, Instruction *InsertBefore);
347  BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
348  const Twine &Name, BasicBlock *InsertAtEnd);
349 
350  // Note: Instruction needs to be a friend here to call cloneImpl.
351  friend class Instruction;
352  BinaryOperator *cloneImpl() const;
353 
354 public:
355  // allocate space for exactly two operands
356  void *operator new(size_t s) {
357  return User::operator new(s, 2);
358  }
359 
360  void *operator new(size_t, unsigned) = delete;
361 
362  /// Transparently provide more efficient getOperand methods.
364 
365  /// Construct a binary instruction, given the opcode and the two
366  /// operands. Optionally (if InstBefore is specified) insert the instruction
367  /// into a BasicBlock right before the specified instruction. The specified
368  /// Instruction is allowed to be a dereferenced end iterator.
369  ///
370  static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
371  const Twine &Name = Twine(),
372  Instruction *InsertBefore = nullptr);
373 
374  /// Construct a binary instruction, given the opcode and the two
375  /// operands. Also automatically insert this instruction to the end of the
376  /// BasicBlock specified.
377  ///
378  static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
379  const Twine &Name, BasicBlock *InsertAtEnd);
380 
381  /// These methods just forward to Create, and are useful when you
382  /// statically know what type of instruction you're going to create. These
383  /// helpers just save some typing.
384 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
385  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
386  const Twine &Name = "") {\
387  return Create(Instruction::OPC, V1, V2, Name);\
388  }
389 #include "llvm/IR/Instruction.def"
390 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
391  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
392  const Twine &Name, BasicBlock *BB) {\
393  return Create(Instruction::OPC, V1, V2, Name, BB);\
394  }
395 #include "llvm/IR/Instruction.def"
396 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
397  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
398  const Twine &Name, Instruction *I) {\
399  return Create(Instruction::OPC, V1, V2, Name, I);\
400  }
401 #include "llvm/IR/Instruction.def"
402 
404  Value *V1, Value *V2,
405  BinaryOperator *CopyBO,
406  const Twine &Name = "") {
407  BinaryOperator *BO = Create(Opc, V1, V2, Name);
408  BO->copyIRFlags(CopyBO);
409  return BO;
410  }
411 
413  const Twine &Name = "") {
414  BinaryOperator *BO = Create(Opc, V1, V2, Name);
415  BO->setHasNoSignedWrap(true);
416  return BO;
417  }
419  const Twine &Name, BasicBlock *BB) {
420  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
421  BO->setHasNoSignedWrap(true);
422  return BO;
423  }
425  const Twine &Name, Instruction *I) {
426  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
427  BO->setHasNoSignedWrap(true);
428  return BO;
429  }
430 
432  const Twine &Name = "") {
433  BinaryOperator *BO = Create(Opc, V1, V2, Name);
434  BO->setHasNoUnsignedWrap(true);
435  return BO;
436  }
438  const Twine &Name, BasicBlock *BB) {
439  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
440  BO->setHasNoUnsignedWrap(true);
441  return BO;
442  }
444  const Twine &Name, Instruction *I) {
445  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
446  BO->setHasNoUnsignedWrap(true);
447  return BO;
448  }
449 
451  const Twine &Name = "") {
452  BinaryOperator *BO = Create(Opc, V1, V2, Name);
453  BO->setIsExact(true);
454  return BO;
455  }
457  const Twine &Name, BasicBlock *BB) {
458  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
459  BO->setIsExact(true);
460  return BO;
461  }
463  const Twine &Name, Instruction *I) {
464  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
465  BO->setIsExact(true);
466  return BO;
467  }
468 
469 #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \
470  static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2, \
471  const Twine &Name = "") { \
472  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \
473  } \
474  static BinaryOperator *Create##NUWNSWEXACT##OPC( \
475  Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \
476  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \
477  } \
478  static BinaryOperator *Create##NUWNSWEXACT##OPC( \
479  Value *V1, Value *V2, const Twine &Name, Instruction *I) { \
480  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \
481  }
482 
483  DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
484  DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
485  DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
486  DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
487  DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
488  DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
489  DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
490  DEFINE_HELPERS(Shl, NUW) // CreateNUWShl
491 
492  DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv
493  DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv
494  DEFINE_HELPERS(AShr, Exact) // CreateExactAShr
495  DEFINE_HELPERS(LShr, Exact) // CreateExactLShr
496 
497 #undef DEFINE_HELPERS
498 
499  /// Helper functions to construct and inspect unary operations (NEG and NOT)
500  /// via binary operators SUB and XOR:
501  ///
502  /// Create the NEG and NOT instructions out of SUB and XOR instructions.
503  ///
504  static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
505  Instruction *InsertBefore = nullptr);
506  static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
507  BasicBlock *InsertAtEnd);
508  static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
509  Instruction *InsertBefore = nullptr);
510  static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
511  BasicBlock *InsertAtEnd);
512  static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
513  Instruction *InsertBefore = nullptr);
514  static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
515  BasicBlock *InsertAtEnd);
516  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
517  Instruction *InsertBefore = nullptr);
518  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name,
519  BasicBlock *InsertAtEnd);
520  static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
521  Instruction *InsertBefore = nullptr);
522  static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
523  BasicBlock *InsertAtEnd);
524 
525  /// Check if the given Value is a NEG, FNeg, or NOT instruction.
526  ///
527  static bool isNeg(const Value *V);
528  static bool isFNeg(const Value *V, bool IgnoreZeroSign=false);
529  static bool isNot(const Value *V);
530 
531  /// Helper functions to extract the unary argument of a NEG, FNEG or NOT
532  /// operation implemented via Sub, FSub, or Xor.
533  ///
534  static const Value *getNegArgument(const Value *BinOp);
535  static Value *getNegArgument( Value *BinOp);
536  static const Value *getFNegArgument(const Value *BinOp);
537  static Value *getFNegArgument( Value *BinOp);
538  static const Value *getNotArgument(const Value *BinOp);
539  static Value *getNotArgument( Value *BinOp);
540 
542  return static_cast<BinaryOps>(Instruction::getOpcode());
543  }
544 
545  /// Exchange the two operands to this instruction.
546  /// This instruction is safe to use on any binary instruction and
547  /// does not modify the semantics of the instruction. If the instruction
548  /// cannot be reversed (ie, it's a Div), then return true.
549  ///
550  bool swapOperands();
551 
552  // Methods for support type inquiry through isa, cast, and dyn_cast:
553  static inline bool classof(const Instruction *I) {
554  return I->isBinaryOp();
555  }
556  static inline bool classof(const Value *V) {
557  return isa<Instruction>(V) && classof(cast<Instruction>(V));
558  }
559 };
560 
561 template <>
563  public FixedNumOperandTraits<BinaryOperator, 2> {
564 };
565 
567 
568 //===----------------------------------------------------------------------===//
569 // CastInst Class
570 //===----------------------------------------------------------------------===//
571 
572 /// This is the base class for all instructions that perform data
573 /// casts. It is simply provided so that instruction category testing
574 /// can be performed with code like:
575 ///
576 /// if (isa<CastInst>(Instr)) { ... }
577 /// @brief Base class of casting instructions.
578 class CastInst : public UnaryInstruction {
579  void anchor() override;
580 
581 protected:
582  /// @brief Constructor with insert-before-instruction semantics for subclasses
583  CastInst(Type *Ty, unsigned iType, Value *S,
584  const Twine &NameStr = "", Instruction *InsertBefore = nullptr)
585  : UnaryInstruction(Ty, iType, S, InsertBefore) {
586  setName(NameStr);
587  }
588  /// @brief Constructor with insert-at-end-of-block semantics for subclasses
589  CastInst(Type *Ty, unsigned iType, Value *S,
590  const Twine &NameStr, BasicBlock *InsertAtEnd)
591  : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
592  setName(NameStr);
593  }
594 
595 public:
596  /// Provides a way to construct any of the CastInst subclasses using an
597  /// opcode instead of the subclass's constructor. The opcode must be in the
598  /// CastOps category (Instruction::isCast(opcode) returns true). This
599  /// constructor has insert-before-instruction semantics to automatically
600  /// insert the new CastInst before InsertBefore (if it is non-null).
601  /// @brief Construct any of the CastInst subclasses
602  static CastInst *Create(
603  Instruction::CastOps, ///< The opcode of the cast instruction
604  Value *S, ///< The value to be casted (operand 0)
605  Type *Ty, ///< The type to which cast should be made
606  const Twine &Name = "", ///< Name for the instruction
607  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
608  );
609  /// Provides a way to construct any of the CastInst subclasses using an
610  /// opcode instead of the subclass's constructor. The opcode must be in the
611  /// CastOps category. This constructor has insert-at-end-of-block semantics
612  /// to automatically insert the new CastInst at the end of InsertAtEnd (if
613  /// its non-null).
614  /// @brief Construct any of the CastInst subclasses
615  static CastInst *Create(
616  Instruction::CastOps, ///< The opcode for the cast instruction
617  Value *S, ///< The value to be casted (operand 0)
618  Type *Ty, ///< The type to which operand is casted
619  const Twine &Name, ///< The name for the instruction
620  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
621  );
622 
623  /// @brief Create a ZExt or BitCast cast instruction
624  static CastInst *CreateZExtOrBitCast(
625  Value *S, ///< The value to be casted (operand 0)
626  Type *Ty, ///< The type to which cast should be made
627  const Twine &Name = "", ///< Name for the instruction
628  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
629  );
630 
631  /// @brief Create a ZExt or BitCast cast instruction
632  static CastInst *CreateZExtOrBitCast(
633  Value *S, ///< The value to be casted (operand 0)
634  Type *Ty, ///< The type to which operand is casted
635  const Twine &Name, ///< The name for the instruction
636  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
637  );
638 
639  /// @brief Create a SExt or BitCast cast instruction
640  static CastInst *CreateSExtOrBitCast(
641  Value *S, ///< The value to be casted (operand 0)
642  Type *Ty, ///< The type to which cast should be made
643  const Twine &Name = "", ///< Name for the instruction
644  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
645  );
646 
647  /// @brief Create a SExt or BitCast cast instruction
648  static CastInst *CreateSExtOrBitCast(
649  Value *S, ///< The value to be casted (operand 0)
650  Type *Ty, ///< The type to which operand is casted
651  const Twine &Name, ///< The name for the instruction
652  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
653  );
654 
655  /// @brief Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
656  static CastInst *CreatePointerCast(
657  Value *S, ///< The pointer value to be casted (operand 0)
658  Type *Ty, ///< The type to which operand is casted
659  const Twine &Name, ///< The name for the instruction
660  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
661  );
662 
663  /// @brief Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
664  static CastInst *CreatePointerCast(
665  Value *S, ///< The pointer value to be casted (operand 0)
666  Type *Ty, ///< The type to which cast should be made
667  const Twine &Name = "", ///< Name for the instruction
668  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
669  );
670 
671  /// @brief Create a BitCast or an AddrSpaceCast cast instruction.
672  static CastInst *CreatePointerBitCastOrAddrSpaceCast(
673  Value *S, ///< The pointer value to be casted (operand 0)
674  Type *Ty, ///< The type to which operand is casted
675  const Twine &Name, ///< The name for the instruction
676  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
677  );
678 
679  /// @brief Create a BitCast or an AddrSpaceCast cast instruction.
680  static CastInst *CreatePointerBitCastOrAddrSpaceCast(
681  Value *S, ///< The pointer value to be casted (operand 0)
682  Type *Ty, ///< The type to which cast should be made
683  const Twine &Name = "", ///< Name for the instruction
684  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
685  );
686 
687  /// @brief Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
688  ///
689  /// If the value is a pointer type and the destination an integer type,
690  /// creates a PtrToInt cast. If the value is an integer type and the
691  /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
692  /// a bitcast.
693  static CastInst *CreateBitOrPointerCast(
694  Value *S, ///< The pointer value to be casted (operand 0)
695  Type *Ty, ///< The type to which cast should be made
696  const Twine &Name = "", ///< Name for the instruction
697  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
698  );
699 
700  /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts.
701  static CastInst *CreateIntegerCast(
702  Value *S, ///< The pointer value to be casted (operand 0)
703  Type *Ty, ///< The type to which cast should be made
704  bool isSigned, ///< Whether to regard S as signed or not
705  const Twine &Name = "", ///< Name for the instruction
706  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
707  );
708 
709  /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts.
710  static CastInst *CreateIntegerCast(
711  Value *S, ///< The integer value to be casted (operand 0)
712  Type *Ty, ///< The integer type to which operand is casted
713  bool isSigned, ///< Whether to regard S as signed or not
714  const Twine &Name, ///< The name for the instruction
715  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
716  );
717 
718  /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
719  static CastInst *CreateFPCast(
720  Value *S, ///< The floating point value to be casted
721  Type *Ty, ///< The floating point type to cast to
722  const Twine &Name = "", ///< Name for the instruction
723  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
724  );
725 
726  /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
727  static CastInst *CreateFPCast(
728  Value *S, ///< The floating point value to be casted
729  Type *Ty, ///< The floating point type to cast to
730  const Twine &Name, ///< The name for the instruction
731  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
732  );
733 
734  /// @brief Create a Trunc or BitCast cast instruction
735  static CastInst *CreateTruncOrBitCast(
736  Value *S, ///< The value to be casted (operand 0)
737  Type *Ty, ///< The type to which cast should be made
738  const Twine &Name = "", ///< Name for the instruction
739  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
740  );
741 
742  /// @brief Create a Trunc or BitCast cast instruction
743  static CastInst *CreateTruncOrBitCast(
744  Value *S, ///< The value to be casted (operand 0)
745  Type *Ty, ///< The type to which operand is casted
746  const Twine &Name, ///< The name for the instruction
747  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
748  );
749 
750  /// @brief Check whether it is valid to call getCastOpcode for these types.
751  static bool isCastable(
752  Type *SrcTy, ///< The Type from which the value should be cast.
753  Type *DestTy ///< The Type to which the value should be cast.
754  );
755 
756  /// @brief Check whether a bitcast between these types is valid
757  static bool isBitCastable(
758  Type *SrcTy, ///< The Type from which the value should be cast.
759  Type *DestTy ///< The Type to which the value should be cast.
760  );
761 
762  /// @brief Check whether a bitcast, inttoptr, or ptrtoint cast between these
763  /// types is valid and a no-op.
764  ///
765  /// This ensures that any pointer<->integer cast has enough bits in the
766  /// integer and any other cast is a bitcast.
767  static bool isBitOrNoopPointerCastable(
768  Type *SrcTy, ///< The Type from which the value should be cast.
769  Type *DestTy, ///< The Type to which the value should be cast.
770  const DataLayout &DL);
771 
772  /// Returns the opcode necessary to cast Val into Ty using usual casting
773  /// rules.
774  /// @brief Infer the opcode for cast operand and type
775  static Instruction::CastOps getCastOpcode(
776  const Value *Val, ///< The value to cast
777  bool SrcIsSigned, ///< Whether to treat the source as signed
778  Type *Ty, ///< The Type to which the value should be casted
779  bool DstIsSigned ///< Whether to treate the dest. as signed
780  );
781 
782  /// There are several places where we need to know if a cast instruction
783  /// only deals with integer source and destination types. To simplify that
784  /// logic, this method is provided.
785  /// @returns true iff the cast has only integral typed operand and dest type.
786  /// @brief Determine if this is an integer-only cast.
787  bool isIntegerCast() const;
788 
789  /// A lossless cast is one that does not alter the basic value. It implies
790  /// a no-op cast but is more stringent, preventing things like int->float,
791  /// long->double, or int->ptr.
792  /// @returns true iff the cast is lossless.
793  /// @brief Determine if this is a lossless cast.
794  bool isLosslessCast() const;
795 
796  /// A no-op cast is one that can be effected without changing any bits.
797  /// It implies that the source and destination types are the same size. The
798  /// IntPtrTy argument is used to make accurate determinations for casts
799  /// involving Integer and Pointer types. They are no-op casts if the integer
800  /// is the same size as the pointer. However, pointer size varies with
801  /// platform. Generally, the result of DataLayout::getIntPtrType() should be
802  /// passed in. If that's not available, use Type::Int64Ty, which will make
803  /// the isNoopCast call conservative.
804  /// @brief Determine if the described cast is a no-op cast.
805  static bool isNoopCast(
806  Instruction::CastOps Opcode, ///< Opcode of cast
807  Type *SrcTy, ///< SrcTy of cast
808  Type *DstTy, ///< DstTy of cast
809  Type *IntPtrTy ///< Integer type corresponding to Ptr types
810  );
811 
812  /// @brief Determine if this cast is a no-op cast.
813  bool isNoopCast(
814  Type *IntPtrTy ///< Integer type corresponding to pointer
815  ) const;
816 
817  /// @brief Determine if this cast is a no-op cast.
818  ///
819  /// \param DL is the DataLayout to get the Int Ptr type from.
820  bool isNoopCast(const DataLayout &DL) const;
821 
822  /// Determine how a pair of casts can be eliminated, if they can be at all.
823  /// This is a helper function for both CastInst and ConstantExpr.
824  /// @returns 0 if the CastInst pair can't be eliminated, otherwise
825  /// returns Instruction::CastOps value for a cast that can replace
826  /// the pair, casting SrcTy to DstTy.
827  /// @brief Determine if a cast pair is eliminable
828  static unsigned isEliminableCastPair(
829  Instruction::CastOps firstOpcode, ///< Opcode of first cast
830  Instruction::CastOps secondOpcode, ///< Opcode of second cast
831  Type *SrcTy, ///< SrcTy of 1st cast
832  Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
833  Type *DstTy, ///< DstTy of 2nd cast
834  Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
835  Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
836  Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null
837  );
838 
839  /// @brief Return the opcode of this CastInst
842  }
843 
844  /// @brief Return the source type, as a convenience
845  Type* getSrcTy() const { return getOperand(0)->getType(); }
846  /// @brief Return the destination type, as a convenience
847  Type* getDestTy() const { return getType(); }
848 
849  /// This method can be used to determine if a cast from S to DstTy using
850  /// Opcode op is valid or not.
851  /// @returns true iff the proposed cast is valid.
852  /// @brief Determine if a cast is valid without creating one.
853  static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy);
854 
855  /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
856  static inline bool classof(const Instruction *I) {
857  return I->isCast();
858  }
859  static inline bool classof(const Value *V) {
860  return isa<Instruction>(V) && classof(cast<Instruction>(V));
861  }
862 };
863 
864 //===----------------------------------------------------------------------===//
865 // CmpInst Class
866 //===----------------------------------------------------------------------===//
867 
868 /// This class is the base class for the comparison instructions.
869 /// @brief Abstract base class of comparison instructions.
870 class CmpInst : public Instruction {
871 public:
872  /// This enumeration lists the possible predicates for CmpInst subclasses.
873  /// Values in the range 0-31 are reserved for FCmpInst, while values in the
874  /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
875  /// predicate values are not overlapping between the classes.
876  ///
877  /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
878  /// FCMP_* values. Changing the bit patterns requires a potential change to
879  /// those passes.
880  enum Predicate {
881  // Opcode U L G E Intuitive operation
882  FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded)
883  FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal
884  FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than
885  FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal
886  FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than
887  FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal
888  FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal
889  FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans)
890  FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
891  FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal
892  FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than
893  FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal
894  FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than
895  FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal
896  FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal
897  FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded)
901  ICMP_EQ = 32, ///< equal
902  ICMP_NE = 33, ///< not equal
903  ICMP_UGT = 34, ///< unsigned greater than
904  ICMP_UGE = 35, ///< unsigned greater or equal
905  ICMP_ULT = 36, ///< unsigned less than
906  ICMP_ULE = 37, ///< unsigned less or equal
907  ICMP_SGT = 38, ///< signed greater than
908  ICMP_SGE = 39, ///< signed greater or equal
909  ICMP_SLT = 40, ///< signed less than
910  ICMP_SLE = 41, ///< signed less or equal
914  };
915 
916 protected:
918  Value *LHS, Value *RHS, const Twine &Name = "",
919  Instruction *InsertBefore = nullptr);
920 
922  Value *LHS, Value *RHS, const Twine &Name,
923  BasicBlock *InsertAtEnd);
924 
925  void anchor() override; // Out of line virtual method.
926 
927 public:
928  CmpInst() = delete;
929 
930  // allocate space for exactly two operands
931  void *operator new(size_t s) {
932  return User::operator new(s, 2);
933  }
934 
935  void *operator new(size_t, unsigned) = delete;
936 
937  /// Construct a compare instruction, given the opcode, the predicate and
938  /// the two operands. Optionally (if InstBefore is specified) insert the
939  /// instruction into a BasicBlock right before the specified instruction.
940  /// The specified Instruction is allowed to be a dereferenced end iterator.
941  /// @brief Create a CmpInst
942  static CmpInst *Create(OtherOps Op,
943  Predicate predicate, Value *S1,
944  Value *S2, const Twine &Name = "",
945  Instruction *InsertBefore = nullptr);
946 
947  /// Construct a compare instruction, given the opcode, the predicate and the
948  /// two operands. Also automatically insert this instruction to the end of
949  /// the BasicBlock specified.
950  /// @brief Create a CmpInst
951  static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1,
952  Value *S2, const Twine &Name, BasicBlock *InsertAtEnd);
953 
954  /// @brief Get the opcode casted to the right type
955  OtherOps getOpcode() const {
956  return static_cast<OtherOps>(Instruction::getOpcode());
957  }
958 
959  /// @brief Return the predicate for this instruction.
962  }
963 
964  /// @brief Set the predicate for this instruction to the specified value.
966 
967  static bool isFPPredicate(Predicate P) {
968  return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE;
969  }
970 
971  static bool isIntPredicate(Predicate P) {
972  return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
973  }
974 
976 
977  bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
978  bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
979 
980  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
981  /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
982  /// @returns the inverse predicate for the instruction's current predicate.
983  /// @brief Return the inverse of the instruction's predicate.
986  }
987 
988  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
989  /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
990  /// @returns the inverse predicate for predicate provided in \p pred.
991  /// @brief Return the inverse of a given predicate
993 
994  /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
995  /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
996  /// @returns the predicate that would be the result of exchanging the two
997  /// operands of the CmpInst instruction without changing the result
998  /// produced.
999  /// @brief Return the predicate as if the operands were swapped
1002  }
1003 
1004  /// This is a static version that you can use without an instruction
1005  /// available.
1006  /// @brief Return the predicate as if the operands were swapped.
1008 
1009  /// @brief Provide more efficient getOperand methods.
1011 
1012  /// This is just a convenience that dispatches to the subclasses.
1013  /// @brief Swap the operands and adjust predicate accordingly to retain
1014  /// the same comparison.
1015  void swapOperands();
1016 
1017  /// This is just a convenience that dispatches to the subclasses.
1018  /// @brief Determine if this CmpInst is commutative.
1019  bool isCommutative() const;
1020 
1021  /// This is just a convenience that dispatches to the subclasses.
1022  /// @brief Determine if this is an equals/not equals predicate.
1023  bool isEquality() const;
1024 
1025  /// @returns true if the comparison is signed, false otherwise.
1026  /// @brief Determine if this instruction is using a signed comparison.
1027  bool isSigned() const {
1028  return isSigned(getPredicate());
1029  }
1030 
1031  /// @returns true if the comparison is unsigned, false otherwise.
1032  /// @brief Determine if this instruction is using an unsigned comparison.
1033  bool isUnsigned() const {
1034  return isUnsigned(getPredicate());
1035  }
1036 
1037  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
1038  /// @returns the signed version of the unsigned predicate pred.
1039  /// @brief return the signed version of a predicate
1041 
1042  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
1043  /// @returns the signed version of the predicate for this instruction (which
1044  /// has to be an unsigned predicate).
1045  /// @brief return the signed version of a predicate
1047  return getSignedPredicate(getPredicate());
1048  }
1049 
1050  /// This is just a convenience.
1051  /// @brief Determine if this is true when both operands are the same.
1052  bool isTrueWhenEqual() const {
1053  return isTrueWhenEqual(getPredicate());
1054  }
1055 
1056  /// This is just a convenience.
1057  /// @brief Determine if this is false when both operands are the same.
1058  bool isFalseWhenEqual() const {
1059  return isFalseWhenEqual(getPredicate());
1060  }
1061 
1062  /// @brief Determine if Pred1 implies Pred2 is true when two compares have
1063  /// matching operands.
1065  return isImpliedTrueByMatchingCmp(getPredicate(), Pred2);
1066  }
1067 
1068  /// @brief Determine if Pred1 implies Pred2 is false when two compares have
1069  /// matching operands.
1071  return isImpliedFalseByMatchingCmp(getPredicate(), Pred2);
1072  }
1073 
1074  /// @returns true if the predicate is unsigned, false otherwise.
1075  /// @brief Determine if the predicate is an unsigned operation.
1076  static bool isUnsigned(Predicate predicate);
1077 
1078  /// @returns true if the predicate is signed, false otherwise.
1079  /// @brief Determine if the predicate is an signed operation.
1080  static bool isSigned(Predicate predicate);
1081 
1082  /// @brief Determine if the predicate is an ordered operation.
1083  static bool isOrdered(Predicate predicate);
1084 
1085  /// @brief Determine if the predicate is an unordered operation.
1086  static bool isUnordered(Predicate predicate);
1087 
1088  /// Determine if the predicate is true when comparing a value with itself.
1089  static bool isTrueWhenEqual(Predicate predicate);
1090 
1091  /// Determine if the predicate is false when comparing a value with itself.
1092  static bool isFalseWhenEqual(Predicate predicate);
1093 
1094  /// Determine if Pred1 implies Pred2 is true when two compares have matching
1095  /// operands.
1096  static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
1097 
1098  /// Determine if Pred1 implies Pred2 is false when two compares have matching
1099  /// operands.
1100  static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
1101 
1102  /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1103  static inline bool classof(const Instruction *I) {
1104  return I->getOpcode() == Instruction::ICmp ||
1105  I->getOpcode() == Instruction::FCmp;
1106  }
1107  static inline bool classof(const Value *V) {
1108  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1109  }
1110 
1111  /// @brief Create a result type for fcmp/icmp
1112  static Type* makeCmpResultType(Type* opnd_type) {
1113  if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
1114  return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
1115  vt->getNumElements());
1116  }
1117  return Type::getInt1Ty(opnd_type->getContext());
1118  }
1119 
1120 private:
1121  // Shadow Value::setValueSubclassData with a private forwarding method so that
1122  // subclasses cannot accidentally use it.
1123  void setValueSubclassData(unsigned short D) {
1125  }
1126 };
1127 
1128 // FIXME: these are redundant if CmpInst < BinaryOperator
1129 template <>
1130 struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
1131 };
1132 
1134 
1135 //===----------------------------------------------------------------------===//
1136 // FuncletPadInst Class
1137 //===----------------------------------------------------------------------===//
1138 class FuncletPadInst : public Instruction {
1139 private:
1140  void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr);
1141 
1142  FuncletPadInst(const FuncletPadInst &CPI);
1143 
1144  explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
1145  ArrayRef<Value *> Args, unsigned Values,
1146  const Twine &NameStr, Instruction *InsertBefore);
1147  explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
1148  ArrayRef<Value *> Args, unsigned Values,
1149  const Twine &NameStr, BasicBlock *InsertAtEnd);
1150 
1151 protected:
1152  // Note: Instruction needs to be a friend here to call cloneImpl.
1153  friend class Instruction;
1154  friend class CatchPadInst;
1155  friend class CleanupPadInst;
1156  FuncletPadInst *cloneImpl() const;
1157 
1158 public:
1159  /// Provide fast operand accessors
1161 
1162  /// getNumArgOperands - Return the number of funcletpad arguments.
1163  ///
1164  unsigned getNumArgOperands() const { return getNumOperands() - 1; }
1165 
1166  /// Convenience accessors
1167 
1168  /// \brief Return the outer EH-pad this funclet is nested within.
1169  ///
1170  /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
1171  /// is a CatchPadInst.
1172  Value *getParentPad() const { return Op<-1>(); }
1173  void setParentPad(Value *ParentPad) {
1174  assert(ParentPad);
1175  Op<-1>() = ParentPad;
1176  }
1177 
1178  /// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
1179  ///
1180  Value *getArgOperand(unsigned i) const { return getOperand(i); }
1181  void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
1182 
1183  /// arg_operands - iteration adapter for range-for loops.
1184  op_range arg_operands() { return op_range(op_begin(), op_end() - 1); }
1185 
1186  /// arg_operands - iteration adapter for range-for loops.
1188  return const_op_range(op_begin(), op_end() - 1);
1189  }
1190 
1191  // Methods for support type inquiry through isa, cast, and dyn_cast:
1192  static inline bool classof(const Instruction *I) { return I->isFuncletPad(); }
1193  static inline bool classof(const Value *V) {
1194  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1195  }
1196 };
1197 
1198 template <>
1200  : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};
1201 
1203 
1204 /// \brief A lightweight accessor for an operand bundle meant to be passed
1205 /// around by value.
1208 
1209  OperandBundleUse() = default;
1211  : Inputs(Inputs), Tag(Tag) {}
1212 
1213  /// \brief Return true if the operand at index \p Idx in this operand bundle
1214  /// has the attribute A.
1215  bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const {
1216  if (isDeoptOperandBundle())
1217  if (A == Attribute::ReadOnly || A == Attribute::NoCapture)
1218  return Inputs[Idx]->getType()->isPointerTy();
1219 
1220  // Conservative answer: no operands have any attributes.
1221  return false;
1222  }
1223 
1224  /// \brief Return the tag of this operand bundle as a string.
1226  return Tag->getKey();
1227  }
1228 
1229  /// \brief Return the tag of this operand bundle as an integer.
1230  ///
1231  /// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag,
1232  /// and this function returns the unique integer getOrInsertBundleTag
1233  /// associated the tag of this operand bundle to.
1234  uint32_t getTagID() const {
1235  return Tag->getValue();
1236  }
1237 
1238  /// \brief Return true if this is a "deopt" operand bundle.
1239  bool isDeoptOperandBundle() const {
1240  return getTagID() == LLVMContext::OB_deopt;
1241  }
1242 
1243  /// \brief Return true if this is a "funclet" operand bundle.
1244  bool isFuncletOperandBundle() const {
1245  return getTagID() == LLVMContext::OB_funclet;
1246  }
1247 
1248 private:
1249  /// \brief Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
1251 };
1252 
1253 /// \brief A container for an operand bundle being viewed as a set of values
1254 /// rather than a set of uses.
1255 ///
1256 /// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and
1257 /// so it is possible to create and pass around "self-contained" instances of
1258 /// OperandBundleDef and ConstOperandBundleDef.
1259 template <typename InputTy> class OperandBundleDefT {
1260  std::string Tag;
1261  std::vector<InputTy> Inputs;
1262 
1263 public:
1264  explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
1265  : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
1266  explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)
1267  : Tag(std::move(Tag)), Inputs(Inputs) {}
1268 
1269  explicit OperandBundleDefT(const OperandBundleUse &OBU) {
1270  Tag = OBU.getTagName();
1271  Inputs.insert(Inputs.end(), OBU.Inputs.begin(), OBU.Inputs.end());
1272  }
1273 
1274  ArrayRef<InputTy> inputs() const { return Inputs; }
1275 
1276  typedef typename std::vector<InputTy>::const_iterator input_iterator;
1277  size_t input_size() const { return Inputs.size(); }
1278  input_iterator input_begin() const { return Inputs.begin(); }
1279  input_iterator input_end() const { return Inputs.end(); }
1280 
1281  StringRef getTag() const { return Tag; }
1282 };
1283 
1286 
1287 /// \brief A mixin to add operand bundle functionality to llvm instruction
1288 /// classes.
1289 ///
1290 /// OperandBundleUser uses the descriptor area co-allocated with the host User
1291 /// to store some meta information about which operands are "normal" operands,
1292 /// and which ones belong to some operand bundle.
1293 ///
1294 /// The layout of an operand bundle user is
1295 ///
1296 /// +-----------uint32_t End-------------------------------------+
1297 /// | |
1298 /// | +--------uint32_t Begin--------------------+ |
1299 /// | | | |
1300 /// ^ ^ v v
1301 /// |------|------|----|----|----|----|----|---------|----|---------|----|-----
1302 /// | BOI0 | BOI1 | .. | DU | U0 | U1 | .. | BOI0_U0 | .. | BOI1_U0 | .. | Un
1303 /// |------|------|----|----|----|----|----|---------|----|---------|----|-----
1304 /// v v ^ ^
1305 /// | | | |
1306 /// | +--------uint32_t Begin------------+ |
1307 /// | |
1308 /// +-----------uint32_t End-----------------------------+
1309 ///
1310 ///
1311 /// BOI0, BOI1 ... are descriptions of operand bundles in this User's use list.
1312 /// These descriptions are installed and managed by this class, and they're all
1313 /// instances of OperandBundleUser<T>::BundleOpInfo.
1314 ///
1315 /// DU is an additional descriptor installed by User's 'operator new' to keep
1316 /// track of the 'BOI0 ... BOIN' co-allocation. OperandBundleUser does not
1317 /// access or modify DU in any way, it's an implementation detail private to
1318 /// User.
1319 ///
1320 /// The regular Use& vector for the User starts at U0. The operand bundle uses
1321 /// are part of the Use& vector, just like normal uses. In the diagram above,
1322 /// the operand bundle uses start at BOI0_U0. Each instance of BundleOpInfo has
1323 /// information about a contiguous set of uses constituting an operand bundle,
1324 /// and the total set of operand bundle uses themselves form a contiguous set of
1325 /// uses (i.e. there are no gaps between uses corresponding to individual
1326 /// operand bundles).
1327 ///
1328 /// This class does not know the location of the set of operand bundle uses
1329 /// within the use list -- that is decided by the User using this class via the
1330 /// BeginIdx argument in populateBundleOperandInfos.
1331 ///
1332 /// Currently operand bundle users with hung-off operands are not supported.
1333 template <typename InstrTy, typename OpIteratorTy> class OperandBundleUser {
1334 public:
1335  /// \brief Return the number of operand bundles associated with this User.
1336  unsigned getNumOperandBundles() const {
1337  return std::distance(bundle_op_info_begin(), bundle_op_info_end());
1338  }
1339 
1340  /// \brief Return true if this User has any operand bundles.
1341  bool hasOperandBundles() const { return getNumOperandBundles() != 0; }
1342 
1343  /// \brief Return the index of the first bundle operand in the Use array.
1344  unsigned getBundleOperandsStartIndex() const {
1345  assert(hasOperandBundles() && "Don't call otherwise!");
1346  return bundle_op_info_begin()->Begin;
1347  }
1348 
1349  /// \brief Return the index of the last bundle operand in the Use array.
1350  unsigned getBundleOperandsEndIndex() const {
1351  assert(hasOperandBundles() && "Don't call otherwise!");
1352  return bundle_op_info_end()[-1].End;
1353  }
1354 
1355  /// Return true if the operand at index \p Idx is a bundle operand.
1356  bool isBundleOperand(unsigned Idx) const {
1357  return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
1358  Idx < getBundleOperandsEndIndex();
1359  }
1360 
1361  /// \brief Return the total number operands (not operand bundles) used by
1362  /// every operand bundle in this OperandBundleUser.
1363  unsigned getNumTotalBundleOperands() const {
1364  if (!hasOperandBundles())
1365  return 0;
1366 
1367  unsigned Begin = getBundleOperandsStartIndex();
1368  unsigned End = getBundleOperandsEndIndex();
1369 
1370  assert(Begin <= End && "Should be!");
1371  return End - Begin;
1372  }
1373 
1374  /// \brief Return the operand bundle at a specific index.
1375  OperandBundleUse getOperandBundleAt(unsigned Index) const {
1376  assert(Index < getNumOperandBundles() && "Index out of bounds!");
1378  }
1379 
1380  /// \brief Return the number of operand bundles with the tag Name attached to
1381  /// this instruction.
1382  unsigned countOperandBundlesOfType(StringRef Name) const {
1383  unsigned Count = 0;
1384  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
1385  if (getOperandBundleAt(i).getTagName() == Name)
1386  Count++;
1387 
1388  return Count;
1389  }
1390 
1391  /// \brief Return the number of operand bundles with the tag ID attached to
1392  /// this instruction.
1394  unsigned Count = 0;
1395  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
1396  if (getOperandBundleAt(i).getTagID() == ID)
1397  Count++;
1398 
1399  return Count;
1400  }
1401 
1402  /// \brief Return an operand bundle by name, if present.
1403  ///
1404  /// It is an error to call this for operand bundle types that may have
1405  /// multiple instances of them on the same instruction.
1407  assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!");
1408 
1409  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
1411  if (U.getTagName() == Name)
1412  return U;
1413  }
1414 
1415  return None;
1416  }
1417 
1418  /// \brief Return an operand bundle by tag ID, if present.
1419  ///
1420  /// It is an error to call this for operand bundle types that may have
1421  /// multiple instances of them on the same instruction.
1423  assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!");
1424 
1425  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
1427  if (U.getTagID() == ID)
1428  return U;
1429  }
1430 
1431  return None;
1432  }
1433 
1434  /// \brief Return the list of operand bundles attached to this instruction as
1435  /// a vector of OperandBundleDefs.
1436  ///
1437  /// This function copies the OperandBundeUse instances associated with this
1438  /// OperandBundleUser to a vector of OperandBundleDefs. Note:
1439  /// OperandBundeUses and OperandBundleDefs are non-trivially *different*
1440  /// representations of operand bundles (see documentation above).
1442  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
1444  }
1445 
1446  /// \brief Return the operand bundle for the operand at index OpIdx.
1447  ///
1448  /// It is an error to call this with an OpIdx that does not correspond to an
1449  /// bundle operand.
1452  }
1453 
1454  /// \brief Return true if this operand bundle user has operand bundles that
1455  /// may read from the heap.
1457  // Implementation note: this is a conservative implementation of operand
1458  // bundle semantics, where *any* operand bundle forces a callsite to be at
1459  // least readonly.
1460  return hasOperandBundles();
1461  }
1462 
1463  /// \brief Return true if this operand bundle user has operand bundles that
1464  /// may write to the heap.
1466  for (auto &BOI : bundle_op_infos()) {
1467  if (BOI.Tag->second == LLVMContext::OB_deopt ||
1468  BOI.Tag->second == LLVMContext::OB_funclet)
1469  continue;
1470 
1471  // This instruction has an operand bundle that is not known to us.
1472  // Assume the worst.
1473  return true;
1474  }
1475 
1476  return false;
1477  }
1478 
1479  /// \brief Return true if the bundle operand at index \p OpIdx has the
1480  /// attribute \p A.
1481  bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const {
1482  auto &BOI = getBundleOpInfoForOperand(OpIdx);
1483  auto OBU = operandBundleFromBundleOpInfo(BOI);
1484  return OBU.operandHasAttr(OpIdx - BOI.Begin, A);
1485  }
1486 
1487  /// \brief Return true if \p Other has the same sequence of operand bundle
1488  /// tags with the same number of operands on each one of them as this
1489  /// OperandBundleUser.
1491  const OperandBundleUser<InstrTy, OpIteratorTy> &Other) const {
1492  if (getNumOperandBundles() != Other.getNumOperandBundles())
1493  return false;
1494 
1496  Other.bundle_op_info_begin());
1497  }
1498 
1499  /// \brief Return true if this operand bundle user contains operand bundles
1500  /// with tags other than those specified in \p IDs.
1502  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
1504  if (!is_contained(IDs, ID))
1505  return true;
1506  }
1507  return false;
1508  }
1509 
1510 protected:
1511  /// \brief Is the function attribute S disallowed by some operand bundle on
1512  /// this operand bundle user?
1514  // Operand bundles only possibly disallow readnone, readonly and argmenonly
1515  // attributes. All String attributes are fine.
1516  return false;
1517  }
1518 
1519  /// \brief Is the function attribute A disallowed by some operand bundle on
1520  /// this operand bundle user?
1522  switch (A) {
1523  default:
1524  return false;
1525 
1526  case Attribute::ArgMemOnly:
1527  return hasReadingOperandBundles();
1528 
1529  case Attribute::ReadNone:
1530  return hasReadingOperandBundles();
1531 
1532  case Attribute::ReadOnly:
1533  return hasClobberingOperandBundles();
1534  }
1535 
1536  llvm_unreachable("switch has a default case!");
1537  }
1538 
1539  /// \brief Used to keep track of an operand bundle. See the main comment on
1540  /// OperandBundleUser above.
1541  struct BundleOpInfo {
1542  /// \brief The operand bundle tag, interned by
1543  /// LLVMContextImpl::getOrInsertBundleTag.
1545 
1546  /// \brief The index in the Use& vector where operands for this operand
1547  /// bundle starts.
1549 
1550  /// \brief The index in the Use& vector where operands for this operand
1551  /// bundle ends.
1553 
1554  bool operator==(const BundleOpInfo &Other) const {
1555  return Tag == Other.Tag && Begin == Other.Begin && End == Other.End;
1556  }
1557  };
1558 
1559  /// \brief Simple helper function to map a BundleOpInfo to an
1560  /// OperandBundleUse.
1562  operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const {
1563  auto op_begin = static_cast<const InstrTy *>(this)->op_begin();
1564  ArrayRef<Use> Inputs(op_begin + BOI.Begin, op_begin + BOI.End);
1565  return OperandBundleUse(BOI.Tag, Inputs);
1566  }
1567 
1568  typedef BundleOpInfo *bundle_op_iterator;
1569  typedef const BundleOpInfo *const_bundle_op_iterator;
1570 
1571  /// \brief Return the start of the list of BundleOpInfo instances associated
1572  /// with this OperandBundleUser.
1574  if (!static_cast<InstrTy *>(this)->hasDescriptor())
1575  return nullptr;
1576 
1577  uint8_t *BytesBegin = static_cast<InstrTy *>(this)->getDescriptor().begin();
1578  return reinterpret_cast<bundle_op_iterator>(BytesBegin);
1579  }
1580 
1581  /// \brief Return the start of the list of BundleOpInfo instances associated
1582  /// with this OperandBundleUser.
1584  auto *NonConstThis =
1585  const_cast<OperandBundleUser<InstrTy, OpIteratorTy> *>(this);
1586  return NonConstThis->bundle_op_info_begin();
1587  }
1588 
1589  /// \brief Return the end of the list of BundleOpInfo instances associated
1590  /// with this OperandBundleUser.
1592  if (!static_cast<InstrTy *>(this)->hasDescriptor())
1593  return nullptr;
1594 
1595  uint8_t *BytesEnd = static_cast<InstrTy *>(this)->getDescriptor().end();
1596  return reinterpret_cast<bundle_op_iterator>(BytesEnd);
1597  }
1598 
1599  /// \brief Return the end of the list of BundleOpInfo instances associated
1600  /// with this OperandBundleUser.
1602  auto *NonConstThis =
1603  const_cast<OperandBundleUser<InstrTy, OpIteratorTy> *>(this);
1604  return NonConstThis->bundle_op_info_end();
1605  }
1606 
1607  /// \brief Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
1610  }
1611 
1612  /// \brief Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
1615  }
1616 
1617  /// \brief Populate the BundleOpInfo instances and the Use& vector from \p
1618  /// Bundles. Return the op_iterator pointing to the Use& one past the last
1619  /// last bundle operand use.
1620  ///
1621  /// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo
1622  /// instance allocated in this User's descriptor.
1624  const unsigned BeginIndex) {
1625  auto It = static_cast<InstrTy *>(this)->op_begin() + BeginIndex;
1626  for (auto &B : Bundles)
1627  It = std::copy(B.input_begin(), B.input_end(), It);
1628 
1629  auto *ContextImpl = static_cast<InstrTy *>(this)->getContext().pImpl;
1630  auto BI = Bundles.begin();
1631  unsigned CurrentIndex = BeginIndex;
1632 
1633  for (auto &BOI : bundle_op_infos()) {
1634  assert(BI != Bundles.end() && "Incorrect allocation?");
1635 
1636  BOI.Tag = ContextImpl->getOrInsertBundleTag(BI->getTag());
1637  BOI.Begin = CurrentIndex;
1638  BOI.End = CurrentIndex + BI->input_size();
1639  CurrentIndex = BOI.End;
1640  BI++;
1641  }
1642 
1643  assert(BI == Bundles.end() && "Incorrect allocation?");
1644 
1645  return It;
1646  }
1647 
1648  /// \brief Return the BundleOpInfo for the operand at index OpIdx.
1649  ///
1650  /// It is an error to call this with an OpIdx that does not correspond to an
1651  /// bundle operand.
1652  const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
1653  for (auto &BOI : bundle_op_infos())
1654  if (BOI.Begin <= OpIdx && OpIdx < BOI.End)
1655  return BOI;
1656 
1657  llvm_unreachable("Did not find operand bundle for operand!");
1658  }
1659 
1660  /// \brief Return the total number of values used in \p Bundles.
1662  unsigned Total = 0;
1663  for (auto &B : Bundles)
1664  Total += B.input_size();
1665  return Total;
1666  }
1667 };
1668 
1669 } // end llvm namespace
1670 
1671 #endif // LLVM_IR_INSTRTYPES_H
TerminatorInst(Type *Ty, Instruction::TermOps iType, Use *Ops, unsigned NumOps, Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:54
bool operator==(const BundleOpInfo &Other) const
Definition: InstrTypes.h:1554
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1181
bool hasReadingOperandBundles() const
Return true if this operand bundle user has operand bundles that may read from the heap...
Definition: InstrTypes.h:1456
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
Definition: InstrTypes.h:1180
bool isImpliedTrueByMatchingCmp(Predicate Pred2)
Determine if Pred1 implies Pred2 is true when two compares have matching operands.
Definition: InstrTypes.h:1064
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:840
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:870
static bool classof(const Instruction *I)
Definition: InstrTypes.h:89
bool operator>(const Self &x) const
Definition: InstrTypes.h:220
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:166
OperandBundleDefT(std::string Tag, ArrayRef< InputTy > Inputs)
Definition: InstrTypes.h:1266
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Definition: InstrTypes.h:1112
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:443
size_t i
Various leaf nodes.
Definition: ISDOpcodes.h:60
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:450
OperandBundleDefT< Value * > OperandBundleDef
Definition: InstrTypes.h:1284
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:418
iterator_range< const_bundle_op_iterator > bundle_op_infos() const
Return the range [bundle_op_info_begin, bundle_op_info_end).
Definition: InstrTypes.h:1613
UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
Definition: InstrTypes.h:299
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
static unsigned CountBundleInputs(ArrayRef< OperandBundleDef > Bundles)
Return the total number of values used in Bundles.
Definition: InstrTypes.h:1661
uint32_t Begin
The index in the Use& vector where operands for this operand bundle starts.
Definition: InstrTypes.h:1548
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:984
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide more efficient getOperand methods.
OperandBundleUse operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const
Simple helper function to map a BundleOpInfo to an OperandBundleUse.
Definition: InstrTypes.h:1562
unsigned less or equal
Definition: InstrTypes.h:906
unsigned less than
Definition: InstrTypes.h:905
const_bundle_op_iterator bundle_op_info_end() const
Return the end of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:1601
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:1027
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:886
virtual unsigned getNumSuccessorsV() const =0
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:896
static bool isOrdered(Predicate predicate)
Determine if the predicate is an ordered operation.
static bool classof(const Value *V)
Definition: InstrTypes.h:859
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:905
#define op(i)
UnaryInstruction(Type *Ty, unsigned iType, Value *V, Instruction *IB=nullptr)
Definition: InstrTypes.h:294
bool isBundleOperand(unsigned Idx) const
Return true if the operand at index Idx is a bundle operand.
Definition: InstrTypes.h:1356
bool isEquality() const
This is just a convenience that dispatches to the subclasses.
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:424
Predicate getSignedPredicate()
For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert.
Definition: InstrTypes.h:1046
bool isCast() const
Definition: Instruction.h:117
void copyIRFlags(const Value *V)
Convenience method to copy supported wrapping, exact, and fast-math flags from V to this instruction...
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
Definition: InstrTypes.h:1375
const_op_range arg_operands() const
arg_operands - iteration adapter for range-for loops.
Definition: InstrTypes.h:1187
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:412
bool isFnAttrDisallowedByOpBundle(StringRef S) const
Is the function attribute S disallowed by some operand bundle on this operand bundle user...
Definition: InstrTypes.h:1513
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:891
bool hasOperandBundlesOtherThan(ArrayRef< uint32_t > IDs) const
Return true if this operand bundle user contains operand bundles with tags other than those specified...
Definition: InstrTypes.h:1501
StringRef getTagName() const
Return the tag of this operand bundle as a string.
Definition: InstrTypes.h:1225
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:890
unsigned getSubclassDataFromInstruction() const
Definition: Instruction.h:588
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:578
CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd)
Constructor with insert-at-end-of-block semantics for subclasses.
Definition: InstrTypes.h:589
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
input_iterator input_end() const
Definition: InstrTypes.h:1279
size_t input_size() const
Definition: InstrTypes.h:1277
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:887
This file contains the simple types necessary to represent the attributes associated with functions a...
unsigned getNumTotalBundleOperands() const
Return the total number operands (not operand bundles) used by every operand bundle in this OperandBu...
Definition: InstrTypes.h:1363
bundle_op_iterator bundle_op_info_begin()
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:1573
OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const
Return the operand bundle for the operand at index OpIdx.
Definition: InstrTypes.h:1450
bool operator<=(const Self &x) const
Definition: InstrTypes.h:209
bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const
Is the function attribute A disallowed by some operand bundle on this operand bundle user...
Definition: InstrTypes.h:1521
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
BB * getSource()
Get the source BB of this iterator.
Definition: InstrTypes.h:257
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag...
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
bool hasClobberingOperandBundles() const
Return true if this operand bundle user has operand bundles that may write to the heap...
Definition: InstrTypes.h:1465
unsigned getNumArgOperands() const
getNumArgOperands - Return the number of funcletpad arguments.
Definition: InstrTypes.h:1164
void setParentPad(Value *ParentPad)
Definition: InstrTypes.h:1173
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
Definition: InstrTypes.h:1336
int operator-(const Self &x) const
Definition: InstrTypes.h:243
static CmpInst * Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, const Twine &Name="", Instruction *InsertBefore=nullptr)
Construct a compare instruction, given the opcode, the predicate and the two operands.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
Used to keep track of an operand bundle.
Definition: InstrTypes.h:1541
void setSuccessor(unsigned idx, BasicBlock *B)
Update the specified successor to point at the provided block.
Definition: InstrTypes.h:84
Self operator-(int Right) const
Definition: InstrTypes.h:241
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
void setInstructionSubclassData(unsigned short D)
Definition: Instruction.h:583
OperandBundleUse(StringMapEntry< uint32_t > *Tag, ArrayRef< Use > Inputs)
Definition: InstrTypes.h:1210
const_bundle_op_iterator bundle_op_info_begin() const
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:1583
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Definition: InstrTypes.h:1341
virtual void setSuccessorV(unsigned idx, BasicBlock *B)=0
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: InstrTypes.h:1441
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:74
succ_range successors()
Definition: InstrTypes.h:280
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: InstrTypes.h:1103
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
static bool isIntPredicate(Predicate P)
Definition: InstrTypes.h:971
StringRef getTag() const
Definition: InstrTypes.h:1281
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
bool isFuncletOperandBundle() const
Return true if this is a "funclet" operand bundle.
Definition: InstrTypes.h:1244
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:79
SuccIterator< TerminatorInst *, BasicBlock > succ_iterator
Definition: InstrTypes.h:263
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1207
OperandBundleDefT< const Value * > ConstOperandBundleDef
Definition: InstrTypes.h:1285
static StringRef getPredicateName(Predicate P)
std::vector< InputTy >::const_iterator input_iterator
Definition: InstrTypes.h:1276
iterator_range< succ_iterator > succ_range
Definition: InstrTypes.h:266
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:431
bool isIntPredicate() const
Definition: InstrTypes.h:978
~TerminatorInst() override
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:437
bool isFalseWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:1058
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:456
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:880
static const unsigned End
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:889
static bool classof(const Value *V)
Definition: InstrTypes.h:556
Type * getSrcTy() const
Return the source type, as a convenience.
Definition: InstrTypes.h:845
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:960
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
Definition: InstrTypes.h:1234
static bool classof(const Instruction *I)
Definition: InstrTypes.h:319
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:897
ArrayRef< InputTy > inputs() const
Definition: InstrTypes.h:1274
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)
Macro for generating in-class operand accessor declarations.
bool isCommutative() const
This is just a convenience that dispatches to the subclasses.
SuccIterator< const TerminatorInst *, const BasicBlock > succ_const_iterator
Definition: InstrTypes.h:265
void anchor() override
~UnaryInstruction() override
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:895
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void swapOperands()
This is just a convenience that dispatches to the subclasses.
OpIteratorTy populateBundleOperandInfos(ArrayRef< OperandBundleDef > Bundles, const unsigned BeginIndex)
Populate the BundleOpInfo instances and the Use& vector from Bundles.
Definition: InstrTypes.h:1623
signed greater than
Definition: InstrTypes.h:907
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
virtual BasicBlock * getSuccessorV(unsigned idx) const =0
Virtual methods - Terminators should overload these and provide inline overrides of non-V methods...
hexagon gen pred
bool isTerminator() const
Definition: Instruction.h:114
Optional< OperandBundleUse > getOperandBundle(uint32_t ID) const
Return an operand bundle by tag ID, if present.
Definition: InstrTypes.h:1422
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:884
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
BinaryOps getOpcode() const
Definition: InstrTypes.h:541
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
TerminatorInst(Type *Ty, Instruction::TermOps iType, Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
Definition: InstrTypes.h:59
OperandBundleDefT(std::string Tag, std::vector< InputTy > Inputs)
Definition: InstrTypes.h:1264
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:1406
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:894
CmpInst()=delete
CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics for subclasses.
Definition: InstrTypes.h:583
signed less than
Definition: InstrTypes.h:909
unsigned getBundleOperandsStartIndex() const
Return the index of the first bundle operand in the Use array.
Definition: InstrTypes.h:1344
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:1052
Type * getDestTy() const
Return the destination type, as a convenience.
Definition: InstrTypes.h:847
bundle_op_iterator bundle_op_info_end()
Return the end of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:1591
#define DEFINE_HELPERS(OPC, NUWNSWEXACT)
Definition: InstrTypes.h:469
Value * getParentPad() const
Convenience accessors.
Definition: InstrTypes.h:1172
iterator_range< succ_const_iterator > succ_const_range
Definition: InstrTypes.h:267
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:1000
void setValueSubclassData(unsigned short D)
Definition: Value.h:616
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Definition: InstrTypes.h:965
signed less or equal
Definition: InstrTypes.h:910
A range adaptor for a pair of iterators.
Class to represent vector types.
Definition: DerivedTypes.h:369
bool hasIdenticalOperandBundleSchema(const OperandBundleUser< InstrTy, OpIteratorTy > &Other) const
Return true if Other has the same sequence of operand bundle tags with the same number of operands on...
Definition: InstrTypes.h:1490
succ_const_range successors() const
Definition: InstrTypes.h:283
static bool isFPPredicate(Predicate P)
Definition: InstrTypes.h:967
A lightweight accessor for an operand bundle meant to be passed around by value.
Definition: InstrTypes.h:1206
bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const
Return true if the operand at index Idx in this operand bundle has the attribute A.
Definition: InstrTypes.h:1215
uint32_t End
The index in the Use& vector where operands for this operand bundle ends.
Definition: InstrTypes.h:1552
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:462
bool isFPPredicate() const
Definition: InstrTypes.h:977
StringMapEntry< uint32_t > * Tag
The operand bundle tag, interned by LLVMContextImpl::getOrInsertBundleTag.
Definition: InstrTypes.h:1544
OperandBundleDefT(const OperandBundleUse &OBU)
Definition: InstrTypes.h:1269
bool isImpliedFalseByMatchingCmp(Predicate Pred2)
Determine if Pred1 implies Pred2 is false when two compares have matching operands.
Definition: InstrTypes.h:1070
bool isFuncletPad() const
Definition: Instruction.h:118
input_iterator input_begin() const
Definition: InstrTypes.h:1278
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, BinaryOperator *CopyBO, const Twine &Name="")
Definition: InstrTypes.h:403
void emplace_back(ArgTypes &&...Args)
Definition: SmallVector.h:635
const BundleOpInfo & getBundleOpInfoForOperand(unsigned OpIdx) const
Return the BundleOpInfo for the operand at index OpIdx.
Definition: InstrTypes.h:1652
bool operator>=(const Self &x) const
Definition: InstrTypes.h:214
bool isDeoptOperandBundle() const
Return true if this is a "deopt" operand bundle.
Definition: InstrTypes.h:1239
const BundleOpInfo * const_bundle_op_iterator
Definition: InstrTypes.h:1569
unsigned greater or equal
Definition: InstrTypes.h:904
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
static bool classof(const Value *V)
Definition: InstrTypes.h:92
bool isBinaryOp() const
Definition: Instruction.h:115
#define I(x, y, z)
Definition: MD5.cpp:54
unsigned countOperandBundlesOfType(uint32_t ID) const
Return the number of operand bundles with the tag ID attached to this instruction.
Definition: InstrTypes.h:1393
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:888
Compile-time customization of User operands.
Definition: User.h:43
bool operator<(const Self &x) const
Definition: InstrTypes.h:203
SuccessorProxy operator[](int offset)
Definition: InstrTypes.h:250
static BinaryOperator * CreateNeg(Value *S1, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
Instruction & operator=(const Instruction &)=delete
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:892
unsigned getBundleOperandsEndIndex() const
Return the index of the last bundle operand in the Use array.
Definition: InstrTypes.h:1350
bool operator==(const Self &x) const
Definition: InstrTypes.h:176
OtherOps getOpcode() const
Get the opcode casted to the right type.
Definition: InstrTypes.h:955
static bool classof(const Value *V)
Definition: InstrTypes.h:1107
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
bool isUnsigned() const
Determine if this instruction is using an unsigned comparison.
Definition: InstrTypes.h:1033
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
op_range arg_operands()
arg_operands - iteration adapter for range-for loops.
Definition: InstrTypes.h:1184
BundleOpInfo * bundle_op_iterator
Definition: InstrTypes.h:1568
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:883
LLVM Value Representation.
Definition: Value.h:71
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:893
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
unsigned getSuccessorIndex() const
This is used to interface between code that wants to operate on terminator instructions directly...
Definition: InstrTypes.h:174
static bool classof(const Value *V)
Definition: InstrTypes.h:326
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:631
A container for an operand bundle being viewed as a set of values rather than a set of uses...
Definition: InstrTypes.h:1259
bool operator!=(const Self &x) const
Definition: InstrTypes.h:177
bool isExceptional() const
Definition: InstrTypes.h:97
iterator_range< bundle_op_iterator > bundle_op_infos()
Return the range [bundle_op_info_begin, bundle_op_info_end).
Definition: InstrTypes.h:1608
unsigned greater than
Definition: InstrTypes.h:903
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:31
Use & Op()
Definition: User.h:117
static bool classof(const Instruction *I)
Definition: InstrTypes.h:553
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:66
bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const
Return true if the bundle operand at index OpIdx has the attribute A.
Definition: InstrTypes.h:1481
unsigned countOperandBundlesOfType(StringRef Name) const
Return the number of operand bundles with the tag Name attached to this instruction.
Definition: InstrTypes.h:1382
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:885
static bool classof(const Instruction *I)
Definition: InstrTypes.h:1192
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
Self operator+(int Right) const
Definition: InstrTypes.h:233
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: InstrTypes.h:856
static bool classof(const Value *V)
Definition: InstrTypes.h:1193
A mixin to add operand bundle functionality to llvm instruction classes.
Definition: InstrTypes.h:1333
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:882
signed greater or equal
Definition: InstrTypes.h:908
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:67
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:783