LLVM  3.7.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/Twine.h"
20 #include "llvm/IR/DerivedTypes.h"
21 #include "llvm/IR/Instruction.h"
22 #include "llvm/IR/OperandTraits.h"
23 
24 namespace llvm {
25 
26 class LLVMContext;
27 
28 //===----------------------------------------------------------------------===//
29 // TerminatorInst Class
30 //===----------------------------------------------------------------------===//
31 
32 /// Subclasses of this class are all able to terminate a basic
33 /// block. Thus, these are all the flow control type of operations.
34 ///
35 class TerminatorInst : public Instruction {
36 protected:
38  Use *Ops, unsigned NumOps,
39  Instruction *InsertBefore = nullptr)
40  : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
41 
43  Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
44  : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
45 
46  // Out of line virtual method, so the vtable, etc has a home.
47  ~TerminatorInst() override;
48 
49  /// Virtual methods - Terminators should overload these and provide inline
50  /// overrides of non-V methods.
51  virtual BasicBlock *getSuccessorV(unsigned idx) const = 0;
52  virtual unsigned getNumSuccessorsV() const = 0;
53  virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0;
54 public:
55 
56  /// Return the number of successors that this terminator has.
57  unsigned getNumSuccessors() const {
58  return getNumSuccessorsV();
59  }
60 
61  /// Return the specified successor.
62  BasicBlock *getSuccessor(unsigned idx) const {
63  return getSuccessorV(idx);
64  }
65 
66  /// Update the specified successor to point at the provided block.
67  void setSuccessor(unsigned idx, BasicBlock *B) {
68  setSuccessorV(idx, B);
69  }
70 
71  // Methods for support type inquiry through isa, cast, and dyn_cast:
72  static inline bool classof(const Instruction *I) {
73  return I->isTerminator();
74  }
75  static inline bool classof(const Value *V) {
76  return isa<Instruction>(V) && classof(cast<Instruction>(V));
77  }
78 };
79 
80 
81 //===----------------------------------------------------------------------===//
82 // UnaryInstruction Class
83 //===----------------------------------------------------------------------===//
84 
85 class UnaryInstruction : public Instruction {
86  void *operator new(size_t, unsigned) = delete;
87 
88 protected:
89  UnaryInstruction(Type *Ty, unsigned iType, Value *V,
90  Instruction *IB = nullptr)
91  : Instruction(Ty, iType, &Op<0>(), 1, IB) {
92  Op<0>() = V;
93  }
94  UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
95  : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
96  Op<0>() = V;
97  }
98 public:
99  // allocate space for exactly one operand
100  void *operator new(size_t s) {
101  return User::operator new(s, 1);
102  }
103 
104  // Out of line virtual method, so the vtable, etc has a home.
105  ~UnaryInstruction() override;
106 
107  /// Transparently provide more efficient getOperand methods.
109 
110  // Methods for support type inquiry through isa, cast, and dyn_cast:
111  static inline bool classof(const Instruction *I) {
112  return I->getOpcode() == Instruction::Alloca ||
113  I->getOpcode() == Instruction::Load ||
114  I->getOpcode() == Instruction::VAArg ||
115  I->getOpcode() == Instruction::ExtractValue ||
116  (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
117  }
118  static inline bool classof(const Value *V) {
119  return isa<Instruction>(V) && classof(cast<Instruction>(V));
120  }
121 };
122 
123 template <>
125  public FixedNumOperandTraits<UnaryInstruction, 1> {
126 };
127 
129 
130 //===----------------------------------------------------------------------===//
131 // BinaryOperator Class
132 //===----------------------------------------------------------------------===//
133 
134 class BinaryOperator : public Instruction {
135  void *operator new(size_t, unsigned) = delete;
136 protected:
137  void init(BinaryOps iType);
138  BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
139  const Twine &Name, Instruction *InsertBefore);
140  BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
141  const Twine &Name, BasicBlock *InsertAtEnd);
142 
143  // Note: Instruction needs to be a friend here to call cloneImpl.
144  friend class Instruction;
145  BinaryOperator *cloneImpl() const;
146 
147 public:
148  // allocate space for exactly two operands
149  void *operator new(size_t s) {
150  return User::operator new(s, 2);
151  }
152 
153  /// Transparently provide more efficient getOperand methods.
155 
156  /// Construct a binary instruction, given the opcode and the two
157  /// operands. Optionally (if InstBefore is specified) insert the instruction
158  /// into a BasicBlock right before the specified instruction. The specified
159  /// Instruction is allowed to be a dereferenced end iterator.
160  ///
161  static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
162  const Twine &Name = Twine(),
163  Instruction *InsertBefore = nullptr);
164 
165  /// Construct a binary instruction, given the opcode and the two
166  /// operands. Also automatically insert this instruction to the end of the
167  /// BasicBlock specified.
168  ///
169  static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
170  const Twine &Name, BasicBlock *InsertAtEnd);
171 
172  /// These methods just forward to Create, and are useful when you
173  /// statically know what type of instruction you're going to create. These
174  /// helpers just save some typing.
175 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
176  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
177  const Twine &Name = "") {\
178  return Create(Instruction::OPC, V1, V2, Name);\
179  }
180 #include "llvm/IR/Instruction.def"
181 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
182  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
183  const Twine &Name, BasicBlock *BB) {\
184  return Create(Instruction::OPC, V1, V2, Name, BB);\
185  }
186 #include "llvm/IR/Instruction.def"
187 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
188  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
189  const Twine &Name, Instruction *I) {\
190  return Create(Instruction::OPC, V1, V2, Name, I);\
191  }
192 #include "llvm/IR/Instruction.def"
193 
195  const Twine &Name = "") {
196  BinaryOperator *BO = Create(Opc, V1, V2, Name);
197  BO->setHasNoSignedWrap(true);
198  return BO;
199  }
201  const Twine &Name, BasicBlock *BB) {
202  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
203  BO->setHasNoSignedWrap(true);
204  return BO;
205  }
207  const Twine &Name, Instruction *I) {
208  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
209  BO->setHasNoSignedWrap(true);
210  return BO;
211  }
212 
214  const Twine &Name = "") {
215  BinaryOperator *BO = Create(Opc, V1, V2, Name);
216  BO->setHasNoUnsignedWrap(true);
217  return BO;
218  }
220  const Twine &Name, BasicBlock *BB) {
221  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
222  BO->setHasNoUnsignedWrap(true);
223  return BO;
224  }
226  const Twine &Name, Instruction *I) {
227  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
228  BO->setHasNoUnsignedWrap(true);
229  return BO;
230  }
231 
233  const Twine &Name = "") {
234  BinaryOperator *BO = Create(Opc, V1, V2, Name);
235  BO->setIsExact(true);
236  return BO;
237  }
239  const Twine &Name, BasicBlock *BB) {
240  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
241  BO->setIsExact(true);
242  return BO;
243  }
245  const Twine &Name, Instruction *I) {
246  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
247  BO->setIsExact(true);
248  return BO;
249  }
250 
251 #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \
252  static BinaryOperator *Create ## NUWNSWEXACT ## OPC \
253  (Value *V1, Value *V2, const Twine &Name = "") { \
254  return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \
255  } \
256  static BinaryOperator *Create ## NUWNSWEXACT ## OPC \
257  (Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \
258  return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \
259  } \
260  static BinaryOperator *Create ## NUWNSWEXACT ## OPC \
261  (Value *V1, Value *V2, const Twine &Name, Instruction *I) { \
262  return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \
263  }
264 
265  DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
266  DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
267  DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
268  DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
269  DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
270  DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
271  DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
272  DEFINE_HELPERS(Shl, NUW) // CreateNUWShl
273 
274  DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv
275  DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv
276  DEFINE_HELPERS(AShr, Exact) // CreateExactAShr
277  DEFINE_HELPERS(LShr, Exact) // CreateExactLShr
278 
279 #undef DEFINE_HELPERS
280 
281  /// Helper functions to construct and inspect unary operations (NEG and NOT)
282  /// via binary operators SUB and XOR:
283  ///
284  /// Create the NEG and NOT instructions out of SUB and XOR instructions.
285  ///
286  static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
287  Instruction *InsertBefore = nullptr);
288  static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
289  BasicBlock *InsertAtEnd);
290  static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
291  Instruction *InsertBefore = nullptr);
292  static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
293  BasicBlock *InsertAtEnd);
294  static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
295  Instruction *InsertBefore = nullptr);
296  static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
297  BasicBlock *InsertAtEnd);
298  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
299  Instruction *InsertBefore = nullptr);
300  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name,
301  BasicBlock *InsertAtEnd);
302  static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
303  Instruction *InsertBefore = nullptr);
304  static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
305  BasicBlock *InsertAtEnd);
306 
307  /// Check if the given Value is a NEG, FNeg, or NOT instruction.
308  ///
309  static bool isNeg(const Value *V);
310  static bool isFNeg(const Value *V, bool IgnoreZeroSign=false);
311  static bool isNot(const Value *V);
312 
313  /// Helper functions to extract the unary argument of a NEG, FNEG or NOT
314  /// operation implemented via Sub, FSub, or Xor.
315  ///
316  static const Value *getNegArgument(const Value *BinOp);
317  static Value *getNegArgument( Value *BinOp);
318  static const Value *getFNegArgument(const Value *BinOp);
319  static Value *getFNegArgument( Value *BinOp);
320  static const Value *getNotArgument(const Value *BinOp);
321  static Value *getNotArgument( Value *BinOp);
322 
324  return static_cast<BinaryOps>(Instruction::getOpcode());
325  }
326 
327  /// Exchange the two operands to this instruction.
328  /// This instruction is safe to use on any binary instruction and
329  /// does not modify the semantics of the instruction. If the instruction
330  /// cannot be reversed (ie, it's a Div), then return true.
331  ///
332  bool swapOperands();
333 
334  /// Set or clear the nsw flag on this instruction, which must be an operator
335  /// which supports this flag. See LangRef.html for the meaning of this flag.
336  void setHasNoUnsignedWrap(bool b = true);
337 
338  /// Set or clear the nsw flag on this instruction, which must be an operator
339  /// which supports this flag. See LangRef.html for the meaning of this flag.
340  void setHasNoSignedWrap(bool b = true);
341 
342  /// Set or clear the exact flag on this instruction, which must be an operator
343  /// which supports this flag. See LangRef.html for the meaning of this flag.
344  void setIsExact(bool b = true);
345 
346  /// Determine whether the no unsigned wrap flag is set.
347  bool hasNoUnsignedWrap() const;
348 
349  /// Determine whether the no signed wrap flag is set.
350  bool hasNoSignedWrap() const;
351 
352  /// Determine whether the exact flag is set.
353  bool isExact() const;
354 
355  /// Convenience method to copy supported wrapping, exact, and fast-math flags
356  /// from V to this instruction.
357  void copyIRFlags(const Value *V);
358 
359  /// Logical 'and' of any supported wrapping, exact, and fast-math flags of
360  /// V and this instruction.
361  void andIRFlags(const Value *V);
362 
363  // Methods for support type inquiry through isa, cast, and dyn_cast:
364  static inline bool classof(const Instruction *I) {
365  return I->isBinaryOp();
366  }
367  static inline bool classof(const Value *V) {
368  return isa<Instruction>(V) && classof(cast<Instruction>(V));
369  }
370 };
371 
372 template <>
374  public FixedNumOperandTraits<BinaryOperator, 2> {
375 };
376 
378 
379 //===----------------------------------------------------------------------===//
380 // CastInst Class
381 //===----------------------------------------------------------------------===//
382 
383 /// This is the base class for all instructions that perform data
384 /// casts. It is simply provided so that instruction category testing
385 /// can be performed with code like:
386 ///
387 /// if (isa<CastInst>(Instr)) { ... }
388 /// @brief Base class of casting instructions.
389 class CastInst : public UnaryInstruction {
390  void anchor() override;
391 protected:
392  /// @brief Constructor with insert-before-instruction semantics for subclasses
393  CastInst(Type *Ty, unsigned iType, Value *S,
394  const Twine &NameStr = "", Instruction *InsertBefore = nullptr)
395  : UnaryInstruction(Ty, iType, S, InsertBefore) {
396  setName(NameStr);
397  }
398  /// @brief Constructor with insert-at-end-of-block semantics for subclasses
399  CastInst(Type *Ty, unsigned iType, Value *S,
400  const Twine &NameStr, BasicBlock *InsertAtEnd)
401  : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
402  setName(NameStr);
403  }
404 public:
405  /// Provides a way to construct any of the CastInst subclasses using an
406  /// opcode instead of the subclass's constructor. The opcode must be in the
407  /// CastOps category (Instruction::isCast(opcode) returns true). This
408  /// constructor has insert-before-instruction semantics to automatically
409  /// insert the new CastInst before InsertBefore (if it is non-null).
410  /// @brief Construct any of the CastInst subclasses
411  static CastInst *Create(
412  Instruction::CastOps, ///< The opcode of the cast instruction
413  Value *S, ///< The value to be casted (operand 0)
414  Type *Ty, ///< The type to which cast should be made
415  const Twine &Name = "", ///< Name for the instruction
416  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
417  );
418  /// Provides a way to construct any of the CastInst subclasses using an
419  /// opcode instead of the subclass's constructor. The opcode must be in the
420  /// CastOps category. This constructor has insert-at-end-of-block semantics
421  /// to automatically insert the new CastInst at the end of InsertAtEnd (if
422  /// its non-null).
423  /// @brief Construct any of the CastInst subclasses
424  static CastInst *Create(
425  Instruction::CastOps, ///< The opcode for the cast instruction
426  Value *S, ///< The value to be casted (operand 0)
427  Type *Ty, ///< The type to which operand is casted
428  const Twine &Name, ///< The name for the instruction
429  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
430  );
431 
432  /// @brief Create a ZExt or BitCast cast instruction
433  static CastInst *CreateZExtOrBitCast(
434  Value *S, ///< The value to be casted (operand 0)
435  Type *Ty, ///< The type to which cast should be made
436  const Twine &Name = "", ///< Name for the instruction
437  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
438  );
439 
440  /// @brief Create a ZExt or BitCast cast instruction
441  static CastInst *CreateZExtOrBitCast(
442  Value *S, ///< The value to be casted (operand 0)
443  Type *Ty, ///< The type to which operand is casted
444  const Twine &Name, ///< The name for the instruction
445  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
446  );
447 
448  /// @brief Create a SExt or BitCast cast instruction
449  static CastInst *CreateSExtOrBitCast(
450  Value *S, ///< The value to be casted (operand 0)
451  Type *Ty, ///< The type to which cast should be made
452  const Twine &Name = "", ///< Name for the instruction
453  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
454  );
455 
456  /// @brief Create a SExt or BitCast cast instruction
457  static CastInst *CreateSExtOrBitCast(
458  Value *S, ///< The value to be casted (operand 0)
459  Type *Ty, ///< The type to which operand is casted
460  const Twine &Name, ///< The name for the instruction
461  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
462  );
463 
464  /// @brief Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
465  static CastInst *CreatePointerCast(
466  Value *S, ///< The pointer value to be casted (operand 0)
467  Type *Ty, ///< The type to which operand is casted
468  const Twine &Name, ///< The name for the instruction
469  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
470  );
471 
472  /// @brief Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
473  static CastInst *CreatePointerCast(
474  Value *S, ///< The pointer value to be casted (operand 0)
475  Type *Ty, ///< The type to which cast should be made
476  const Twine &Name = "", ///< Name for the instruction
477  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
478  );
479 
480  /// @brief Create a BitCast or an AddrSpaceCast cast instruction.
481  static CastInst *CreatePointerBitCastOrAddrSpaceCast(
482  Value *S, ///< The pointer value to be casted (operand 0)
483  Type *Ty, ///< The type to which operand is casted
484  const Twine &Name, ///< The name for the instruction
485  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
486  );
487 
488  /// @brief Create a BitCast or an AddrSpaceCast cast instruction.
489  static CastInst *CreatePointerBitCastOrAddrSpaceCast(
490  Value *S, ///< The pointer value to be casted (operand 0)
491  Type *Ty, ///< The type to which cast should be made
492  const Twine &Name = "", ///< Name for the instruction
493  Instruction *InsertBefore = 0 ///< Place to insert the instruction
494  );
495 
496  /// @brief Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
497  ///
498  /// If the value is a pointer type and the destination an integer type,
499  /// creates a PtrToInt cast. If the value is an integer type and the
500  /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
501  /// a bitcast.
502  static CastInst *CreateBitOrPointerCast(
503  Value *S, ///< The pointer value to be casted (operand 0)
504  Type *Ty, ///< The type to which cast should be made
505  const Twine &Name = "", ///< Name for the instruction
506  Instruction *InsertBefore = 0 ///< Place to insert the instruction
507  );
508 
509  /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts.
510  static CastInst *CreateIntegerCast(
511  Value *S, ///< The pointer value to be casted (operand 0)
512  Type *Ty, ///< The type to which cast should be made
513  bool isSigned, ///< Whether to regard S as signed or not
514  const Twine &Name = "", ///< Name for the instruction
515  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
516  );
517 
518  /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts.
519  static CastInst *CreateIntegerCast(
520  Value *S, ///< The integer value to be casted (operand 0)
521  Type *Ty, ///< The integer type to which operand is casted
522  bool isSigned, ///< Whether to regard S as signed or not
523  const Twine &Name, ///< The name for the instruction
524  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
525  );
526 
527  /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
528  static CastInst *CreateFPCast(
529  Value *S, ///< The floating point value to be casted
530  Type *Ty, ///< The floating point type to cast to
531  const Twine &Name = "", ///< Name for the instruction
532  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
533  );
534 
535  /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
536  static CastInst *CreateFPCast(
537  Value *S, ///< The floating point value to be casted
538  Type *Ty, ///< The floating point type to cast to
539  const Twine &Name, ///< The name for the instruction
540  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
541  );
542 
543  /// @brief Create a Trunc or BitCast cast instruction
544  static CastInst *CreateTruncOrBitCast(
545  Value *S, ///< The value to be casted (operand 0)
546  Type *Ty, ///< The type to which cast should be made
547  const Twine &Name = "", ///< Name for the instruction
548  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
549  );
550 
551  /// @brief Create a Trunc or BitCast cast instruction
552  static CastInst *CreateTruncOrBitCast(
553  Value *S, ///< The value to be casted (operand 0)
554  Type *Ty, ///< The type to which operand is casted
555  const Twine &Name, ///< The name for the instruction
556  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
557  );
558 
559  /// @brief Check whether it is valid to call getCastOpcode for these types.
560  static bool isCastable(
561  Type *SrcTy, ///< The Type from which the value should be cast.
562  Type *DestTy ///< The Type to which the value should be cast.
563  );
564 
565  /// @brief Check whether a bitcast between these types is valid
566  static bool isBitCastable(
567  Type *SrcTy, ///< The Type from which the value should be cast.
568  Type *DestTy ///< The Type to which the value should be cast.
569  );
570 
571  /// @brief Check whether a bitcast, inttoptr, or ptrtoint cast between these
572  /// types is valid and a no-op.
573  ///
574  /// This ensures that any pointer<->integer cast has enough bits in the
575  /// integer and any other cast is a bitcast.
576  static bool isBitOrNoopPointerCastable(
577  Type *SrcTy, ///< The Type from which the value should be cast.
578  Type *DestTy, ///< The Type to which the value should be cast.
579  const DataLayout &DL);
580 
581  /// Returns the opcode necessary to cast Val into Ty using usual casting
582  /// rules.
583  /// @brief Infer the opcode for cast operand and type
584  static Instruction::CastOps getCastOpcode(
585  const Value *Val, ///< The value to cast
586  bool SrcIsSigned, ///< Whether to treat the source as signed
587  Type *Ty, ///< The Type to which the value should be casted
588  bool DstIsSigned ///< Whether to treate the dest. as signed
589  );
590 
591  /// There are several places where we need to know if a cast instruction
592  /// only deals with integer source and destination types. To simplify that
593  /// logic, this method is provided.
594  /// @returns true iff the cast has only integral typed operand and dest type.
595  /// @brief Determine if this is an integer-only cast.
596  bool isIntegerCast() const;
597 
598  /// A lossless cast is one that does not alter the basic value. It implies
599  /// a no-op cast but is more stringent, preventing things like int->float,
600  /// long->double, or int->ptr.
601  /// @returns true iff the cast is lossless.
602  /// @brief Determine if this is a lossless cast.
603  bool isLosslessCast() const;
604 
605  /// A no-op cast is one that can be effected without changing any bits.
606  /// It implies that the source and destination types are the same size. The
607  /// IntPtrTy argument is used to make accurate determinations for casts
608  /// involving Integer and Pointer types. They are no-op casts if the integer
609  /// is the same size as the pointer. However, pointer size varies with
610  /// platform. Generally, the result of DataLayout::getIntPtrType() should be
611  /// passed in. If that's not available, use Type::Int64Ty, which will make
612  /// the isNoopCast call conservative.
613  /// @brief Determine if the described cast is a no-op cast.
614  static bool isNoopCast(
615  Instruction::CastOps Opcode, ///< Opcode of cast
616  Type *SrcTy, ///< SrcTy of cast
617  Type *DstTy, ///< DstTy of cast
618  Type *IntPtrTy ///< Integer type corresponding to Ptr types
619  );
620 
621  /// @brief Determine if this cast is a no-op cast.
622  bool isNoopCast(
623  Type *IntPtrTy ///< Integer type corresponding to pointer
624  ) const;
625 
626  /// @brief Determine if this cast is a no-op cast.
627  ///
628  /// \param DL is the DataLayout to get the Int Ptr type from.
629  bool isNoopCast(const DataLayout &DL) const;
630 
631  /// Determine how a pair of casts can be eliminated, if they can be at all.
632  /// This is a helper function for both CastInst and ConstantExpr.
633  /// @returns 0 if the CastInst pair can't be eliminated, otherwise
634  /// returns Instruction::CastOps value for a cast that can replace
635  /// the pair, casting SrcTy to DstTy.
636  /// @brief Determine if a cast pair is eliminable
637  static unsigned isEliminableCastPair(
638  Instruction::CastOps firstOpcode, ///< Opcode of first cast
639  Instruction::CastOps secondOpcode, ///< Opcode of second cast
640  Type *SrcTy, ///< SrcTy of 1st cast
641  Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
642  Type *DstTy, ///< DstTy of 2nd cast
643  Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
644  Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
645  Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null
646  );
647 
648  /// @brief Return the opcode of this CastInst
651  }
652 
653  /// @brief Return the source type, as a convenience
654  Type* getSrcTy() const { return getOperand(0)->getType(); }
655  /// @brief Return the destination type, as a convenience
656  Type* getDestTy() const { return getType(); }
657 
658  /// This method can be used to determine if a cast from S to DstTy using
659  /// Opcode op is valid or not.
660  /// @returns true iff the proposed cast is valid.
661  /// @brief Determine if a cast is valid without creating one.
662  static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy);
663 
664  /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
665  static inline bool classof(const Instruction *I) {
666  return I->isCast();
667  }
668  static inline bool classof(const Value *V) {
669  return isa<Instruction>(V) && classof(cast<Instruction>(V));
670  }
671 };
672 
673 //===----------------------------------------------------------------------===//
674 // CmpInst Class
675 //===----------------------------------------------------------------------===//
676 
677 /// This class is the base class for the comparison instructions.
678 /// @brief Abstract base class of comparison instructions.
679 class CmpInst : public Instruction {
680  void *operator new(size_t, unsigned) = delete;
681  CmpInst() = delete;
682 protected:
683  CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred,
684  Value *LHS, Value *RHS, const Twine &Name = "",
685  Instruction *InsertBefore = nullptr);
686 
687  CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred,
688  Value *LHS, Value *RHS, const Twine &Name,
689  BasicBlock *InsertAtEnd);
690 
691  void anchor() override; // Out of line virtual method.
692 public:
693  /// This enumeration lists the possible predicates for CmpInst subclasses.
694  /// Values in the range 0-31 are reserved for FCmpInst, while values in the
695  /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
696  /// predicate values are not overlapping between the classes.
697  enum Predicate {
698  // Opcode U L G E Intuitive operation
699  FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded)
700  FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal
701  FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than
702  FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal
703  FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than
704  FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal
705  FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal
706  FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans)
707  FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
708  FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal
709  FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than
710  FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal
711  FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than
712  FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal
713  FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal
714  FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded)
718  ICMP_EQ = 32, ///< equal
719  ICMP_NE = 33, ///< not equal
720  ICMP_UGT = 34, ///< unsigned greater than
721  ICMP_UGE = 35, ///< unsigned greater or equal
722  ICMP_ULT = 36, ///< unsigned less than
723  ICMP_ULE = 37, ///< unsigned less or equal
724  ICMP_SGT = 38, ///< signed greater than
725  ICMP_SGE = 39, ///< signed greater or equal
726  ICMP_SLT = 40, ///< signed less than
727  ICMP_SLE = 41, ///< signed less or equal
731  };
732 
733  // allocate space for exactly two operands
734  void *operator new(size_t s) {
735  return User::operator new(s, 2);
736  }
737  /// Construct a compare instruction, given the opcode, the predicate and
738  /// the two operands. Optionally (if InstBefore is specified) insert the
739  /// instruction into a BasicBlock right before the specified instruction.
740  /// The specified Instruction is allowed to be a dereferenced end iterator.
741  /// @brief Create a CmpInst
742  static CmpInst *Create(OtherOps Op,
743  unsigned short predicate, Value *S1,
744  Value *S2, const Twine &Name = "",
745  Instruction *InsertBefore = nullptr);
746 
747  /// Construct a compare instruction, given the opcode, the predicate and the
748  /// two operands. Also automatically insert this instruction to the end of
749  /// the BasicBlock specified.
750  /// @brief Create a CmpInst
751  static CmpInst *Create(OtherOps Op, unsigned short predicate, Value *S1,
752  Value *S2, const Twine &Name, BasicBlock *InsertAtEnd);
753 
754  /// @brief Get the opcode casted to the right type
755  OtherOps getOpcode() const {
756  return static_cast<OtherOps>(Instruction::getOpcode());
757  }
758 
759  /// @brief Return the predicate for this instruction.
762  }
763 
764  /// @brief Set the predicate for this instruction to the specified value.
766 
767  static bool isFPPredicate(Predicate P) {
768  return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE;
769  }
770 
771  static bool isIntPredicate(Predicate P) {
772  return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
773  }
774 
775  bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
776  bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
777 
778 
779  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
780  /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
781  /// @returns the inverse predicate for the instruction's current predicate.
782  /// @brief Return the inverse of the instruction's predicate.
785  }
786 
787  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
788  /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
789  /// @returns the inverse predicate for predicate provided in \p pred.
790  /// @brief Return the inverse of a given predicate
792 
793  /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
794  /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
795  /// @returns the predicate that would be the result of exchanging the two
796  /// operands of the CmpInst instruction without changing the result
797  /// produced.
798  /// @brief Return the predicate as if the operands were swapped
801  }
802 
803  /// This is a static version that you can use without an instruction
804  /// available.
805  /// @brief Return the predicate as if the operands were swapped.
807 
808  /// @brief Provide more efficient getOperand methods.
810 
811  /// This is just a convenience that dispatches to the subclasses.
812  /// @brief Swap the operands and adjust predicate accordingly to retain
813  /// the same comparison.
814  void swapOperands();
815 
816  /// This is just a convenience that dispatches to the subclasses.
817  /// @brief Determine if this CmpInst is commutative.
818  bool isCommutative() const;
819 
820  /// This is just a convenience that dispatches to the subclasses.
821  /// @brief Determine if this is an equals/not equals predicate.
822  bool isEquality() const;
823 
824  /// @returns true if the comparison is signed, false otherwise.
825  /// @brief Determine if this instruction is using a signed comparison.
826  bool isSigned() const {
827  return isSigned(getPredicate());
828  }
829 
830  /// @returns true if the comparison is unsigned, false otherwise.
831  /// @brief Determine if this instruction is using an unsigned comparison.
832  bool isUnsigned() const {
833  return isUnsigned(getPredicate());
834  }
835 
836  /// This is just a convenience.
837  /// @brief Determine if this is true when both operands are the same.
838  bool isTrueWhenEqual() const {
839  return isTrueWhenEqual(getPredicate());
840  }
841 
842  /// This is just a convenience.
843  /// @brief Determine if this is false when both operands are the same.
844  bool isFalseWhenEqual() const {
845  return isFalseWhenEqual(getPredicate());
846  }
847 
848  /// @returns true if the predicate is unsigned, false otherwise.
849  /// @brief Determine if the predicate is an unsigned operation.
850  static bool isUnsigned(unsigned short predicate);
851 
852  /// @returns true if the predicate is signed, false otherwise.
853  /// @brief Determine if the predicate is an signed operation.
854  static bool isSigned(unsigned short predicate);
855 
856  /// @brief Determine if the predicate is an ordered operation.
857  static bool isOrdered(unsigned short predicate);
858 
859  /// @brief Determine if the predicate is an unordered operation.
860  static bool isUnordered(unsigned short predicate);
861 
862  /// Determine if the predicate is true when comparing a value with itself.
863  static bool isTrueWhenEqual(unsigned short predicate);
864 
865  /// Determine if the predicate is false when comparing a value with itself.
866  static bool isFalseWhenEqual(unsigned short predicate);
867 
868  /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
869  static inline bool classof(const Instruction *I) {
870  return I->getOpcode() == Instruction::ICmp ||
871  I->getOpcode() == Instruction::FCmp;
872  }
873  static inline bool classof(const Value *V) {
874  return isa<Instruction>(V) && classof(cast<Instruction>(V));
875  }
876 
877  /// @brief Create a result type for fcmp/icmp
878  static Type* makeCmpResultType(Type* opnd_type) {
879  if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
880  return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
881  vt->getNumElements());
882  }
883  return Type::getInt1Ty(opnd_type->getContext());
884  }
885 private:
886  // Shadow Value::setValueSubclassData with a private forwarding method so that
887  // subclasses cannot accidentally use it.
888  void setValueSubclassData(unsigned short D) {
890  }
891 };
892 
893 
894 // FIXME: these are redundant if CmpInst < BinaryOperator
895 template <>
896 struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
897 };
898 
900 
901 } // End llvm namespace
902 
903 #endif
TerminatorInst(Type *Ty, Instruction::TermOps iType, Use *Ops, unsigned NumOps, Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:37
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:649
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:679
static bool classof(const Instruction *I)
Definition: InstrTypes.h:72
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:236
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Definition: InstrTypes.h:878
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:225
Various leaf nodes.
Definition: ISDOpcodes.h:60
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:232
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:200
UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
Definition: InstrTypes.h:94
static bool isOrdered(unsigned short predicate)
Determine if the predicate is an ordered operation.
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:783
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide more efficient getOperand methods.
unsigned less or equal
Definition: InstrTypes.h:723
unsigned less than
Definition: InstrTypes.h:722
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:826
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:703
virtual unsigned getNumSuccessorsV() const =0
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:713
static bool classof(const Value *V)
Definition: InstrTypes.h:668
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
#define op(i)
UnaryInstruction(Type *Ty, unsigned iType, Value *V, Instruction *IB=nullptr)
Definition: InstrTypes.h:89
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:206
bool isCast() const
Definition: Instruction.h:118
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:194
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:708
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:707
unsigned getSubclassDataFromInstruction() const
Definition: Instruction.h:504
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:389
static Instruction::CastOps isEliminableCastPair(const CastInst *CI, unsigned opcode, Type *DstTy, const DataLayout &DL)
This function is a wrapper around CastInst::isEliminableCastPair.
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:399
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:704
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:125
void setSuccessor(unsigned idx, BasicBlock *B)
Update the specified successor to point at the provided block.
Definition: InstrTypes.h:67
void setInstructionSubclassData(unsigned short D)
Definition: Instruction.h:499
virtual void setSuccessorV(unsigned idx, BasicBlock *B)=0
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:57
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: InstrTypes.h:869
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
static bool isIntPredicate(Predicate P)
Definition: InstrTypes.h:771
static CmpInst * Create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2, const Twine &Name="", Instruction *InsertBefore=nullptr)
Construct a compare instruction, given the opcode, the predicate and the two operands.
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
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:62
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:213
bool isIntPredicate() const
Definition: InstrTypes.h:776
~TerminatorInst() override
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:219
bool isFalseWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:844
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:238
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:697
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:706
static bool classof(const Value *V)
Definition: InstrTypes.h:367
Type * getSrcTy() const
Return the source type, as a convenience.
Definition: InstrTypes.h:654
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:760
static bool classof(const Instruction *I)
Definition: InstrTypes.h:111
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:714
#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.
void anchor() override
~UnaryInstruction() override
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:712
void swapOperands()
This is just a convenience that dispatches to the subclasses.
signed greater than
Definition: InstrTypes.h:724
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...
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag...
hexagon gen pred
bool isTerminator() const
Definition: Instruction.h:115
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:701
BinaryOps getOpcode() const
Definition: InstrTypes.h:323
TerminatorInst(Type *Ty, Instruction::TermOps iType, Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
Definition: InstrTypes.h:42
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:711
CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics for subclasses.
Definition: InstrTypes.h:393
signed less than
Definition: InstrTypes.h:726
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:838
Type * getDestTy() const
Return the destination type, as a convenience.
Definition: InstrTypes.h:656
#define DEFINE_HELPERS(OPC, NUWNSWEXACT)
Definition: InstrTypes.h:251
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:799
void setValueSubclassData(unsigned short D)
Definition: Value.h:508
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Definition: InstrTypes.h:765
signed less or equal
Definition: InstrTypes.h:727
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
static bool isFPPredicate(Predicate P)
Definition: InstrTypes.h:767
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:244
bool isFPPredicate() const
Definition: InstrTypes.h:775
unsigned greater or equal
Definition: InstrTypes.h:721
static bool classof(const Value *V)
Definition: InstrTypes.h:75
bool isBinaryOp() const
Definition: Instruction.h:116
#define I(x, y, z)
Definition: MD5.cpp:54
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:705
Compile-time customization of User operands.
Definition: User.h:34
static BinaryOperator * CreateNeg(Value *S1, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:709
OtherOps getOpcode() const
Get the opcode casted to the right type.
Definition: InstrTypes.h:755
static bool classof(const Value *V)
Definition: InstrTypes.h:873
bool isUnsigned() const
Determine if this instruction is using an unsigned comparison.
Definition: InstrTypes.h:832
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:700
LLVM Value Representation.
Definition: Value.h:69
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:710
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
static bool classof(const Value *V)
Definition: InstrTypes.h:118
static VectorType * get(Type *ElementType, unsigned NumElements)
VectorType::get - This static method is the primary way to construct an VectorType.
Definition: Type.cpp:713
static bool isUnordered(unsigned short predicate)
Determine if the predicate is an unordered operation.
unsigned greater than
Definition: InstrTypes.h:720
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:93
static bool classof(const Instruction *I)
Definition: InstrTypes.h:364
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:702
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: InstrTypes.h:665
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:699
signed greater or equal
Definition: InstrTypes.h:725