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