| //===-- llvm/InstrTypes.h - Important Instruction subclasses ----*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines various meta classes of instructions that exist in the VM |
| // representation. Specific concrete subclasses of these may be found in the |
| // i*.h files... |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_INSTRUCTION_TYPES_H |
| #define LLVM_INSTRUCTION_TYPES_H |
| |
| #include "llvm/Instruction.h" |
| #include "llvm/OperandTraits.h" |
| #include "llvm/DerivedTypes.h" |
| #include "llvm/ADT/Twine.h" |
| |
| namespace llvm { |
| |
| class LLVMContext; |
| |
| //===----------------------------------------------------------------------===// |
| // TerminatorInst Class |
| //===----------------------------------------------------------------------===// |
| |
| /// TerminatorInst - Subclasses of this class are all able to terminate a basic |
| /// block. Thus, these are all the flow control type of operations. |
| /// |
| class TerminatorInst : public Instruction { |
| protected: |
| TerminatorInst(Type *Ty, Instruction::TermOps iType, |
| Use *Ops, unsigned NumOps, |
| Instruction *InsertBefore = 0) |
| : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {} |
| |
| TerminatorInst(Type *Ty, Instruction::TermOps iType, |
| Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd) |
| : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {} |
| |
| // Out of line virtual method, so the vtable, etc has a home. |
| ~TerminatorInst(); |
| |
| /// Virtual methods - Terminators should overload these and provide inline |
| /// overrides of non-V methods. |
| virtual BasicBlock *getSuccessorV(unsigned idx) const = 0; |
| virtual unsigned getNumSuccessorsV() const = 0; |
| virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0; |
| virtual TerminatorInst *clone_impl() const = 0; |
| public: |
| |
| /// getNumSuccessors - Return the number of successors that this terminator |
| /// has. |
| unsigned getNumSuccessors() const { |
| return getNumSuccessorsV(); |
| } |
| |
| /// getSuccessor - Return the specified successor. |
| /// |
| BasicBlock *getSuccessor(unsigned idx) const { |
| return getSuccessorV(idx); |
| } |
| |
| /// setSuccessor - Update the specified successor to point at the provided |
| /// block. |
| void setSuccessor(unsigned idx, BasicBlock *B) { |
| setSuccessorV(idx, B); |
| } |
| |
| // Methods for support type inquiry through isa, cast, and dyn_cast: |
| static inline bool classof(const TerminatorInst *) { return true; } |
| static inline bool classof(const Instruction *I) { |
| return I->isTerminator(); |
| } |
| static inline bool classof(const Value *V) { |
| return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| } |
| }; |
| |
| |
| //===----------------------------------------------------------------------===// |
| // UnaryInstruction Class |
| //===----------------------------------------------------------------------===// |
| |
| class UnaryInstruction : public Instruction { |
| void *operator new(size_t, unsigned); // Do not implement |
| |
| protected: |
| UnaryInstruction(Type *Ty, unsigned iType, Value *V, |
| Instruction *IB = 0) |
| : Instruction(Ty, iType, &Op<0>(), 1, IB) { |
| Op<0>() = V; |
| } |
| UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE) |
| : Instruction(Ty, iType, &Op<0>(), 1, IAE) { |
| Op<0>() = V; |
| } |
| public: |
| // allocate space for exactly one operand |
| void *operator new(size_t s) { |
| return User::operator new(s, 1); |
| } |
| |
| // Out of line virtual method, so the vtable, etc has a home. |
| ~UnaryInstruction(); |
| |
| /// Transparently provide more efficient getOperand methods. |
| DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); |
| |
| // Methods for support type inquiry through isa, cast, and dyn_cast: |
| static inline bool classof(const UnaryInstruction *) { return true; } |
| static inline bool classof(const Instruction *I) { |
| return I->getOpcode() == Instruction::Alloca || |
| I->getOpcode() == Instruction::Load || |
| I->getOpcode() == Instruction::VAArg || |
| I->getOpcode() == Instruction::ExtractValue || |
| (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd); |
| } |
| static inline bool classof(const Value *V) { |
| return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| } |
| }; |
| |
| template <> |
| struct OperandTraits<UnaryInstruction> : |
| public FixedNumOperandTraits<UnaryInstruction, 1> { |
| }; |
| |
| DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value) |
| |
| //===----------------------------------------------------------------------===// |
| // BinaryOperator Class |
| //===----------------------------------------------------------------------===// |
| |
| class BinaryOperator : public Instruction { |
| void *operator new(size_t, unsigned); // Do not implement |
| protected: |
| void init(BinaryOps iType); |
| BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, |
| const Twine &Name, Instruction *InsertBefore); |
| BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, |
| const Twine &Name, BasicBlock *InsertAtEnd); |
| virtual BinaryOperator *clone_impl() const; |
| public: |
| // allocate space for exactly two operands |
| void *operator new(size_t s) { |
| return User::operator new(s, 2); |
| } |
| |
| /// Transparently provide more efficient getOperand methods. |
| DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); |
| |
| /// Create() - Construct a binary instruction, given the opcode and the two |
| /// operands. Optionally (if InstBefore is specified) insert the instruction |
| /// into a BasicBlock right before the specified instruction. The specified |
| /// Instruction is allowed to be a dereferenced end iterator. |
| /// |
| static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, |
| const Twine &Name = Twine(), |
| Instruction *InsertBefore = 0); |
| |
| /// Create() - Construct a binary instruction, given the opcode and the two |
| /// operands. Also automatically insert this instruction to the end of the |
| /// BasicBlock specified. |
| /// |
| static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, |
| const Twine &Name, BasicBlock *InsertAtEnd); |
| |
| /// Create* - These methods just forward to Create, and are useful when you |
| /// statically know what type of instruction you're going to create. These |
| /// helpers just save some typing. |
| #define HANDLE_BINARY_INST(N, OPC, CLASS) \ |
| static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ |
| const Twine &Name = "") {\ |
| return Create(Instruction::OPC, V1, V2, Name);\ |
| } |
| #include "llvm/Instruction.def" |
| #define HANDLE_BINARY_INST(N, OPC, CLASS) \ |
| static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ |
| const Twine &Name, BasicBlock *BB) {\ |
| return Create(Instruction::OPC, V1, V2, Name, BB);\ |
| } |
| #include "llvm/Instruction.def" |
| #define HANDLE_BINARY_INST(N, OPC, CLASS) \ |
| static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ |
| const Twine &Name, Instruction *I) {\ |
| return Create(Instruction::OPC, V1, V2, Name, I);\ |
| } |
| #include "llvm/Instruction.def" |
| |
| static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name = "") { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| BO->setHasNoSignedWrap(true); |
| return BO; |
| } |
| static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name, BasicBlock *BB) { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); |
| BO->setHasNoSignedWrap(true); |
| return BO; |
| } |
| static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name, Instruction *I) { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name, I); |
| BO->setHasNoSignedWrap(true); |
| return BO; |
| } |
| |
| static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name = "") { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| BO->setHasNoUnsignedWrap(true); |
| return BO; |
| } |
| static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name, BasicBlock *BB) { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); |
| BO->setHasNoUnsignedWrap(true); |
| return BO; |
| } |
| static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name, Instruction *I) { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name, I); |
| BO->setHasNoUnsignedWrap(true); |
| return BO; |
| } |
| |
| static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name = "") { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name); |
| BO->setIsExact(true); |
| return BO; |
| } |
| static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name, BasicBlock *BB) { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); |
| BO->setIsExact(true); |
| return BO; |
| } |
| static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, |
| const Twine &Name, Instruction *I) { |
| BinaryOperator *BO = Create(Opc, V1, V2, Name, I); |
| BO->setIsExact(true); |
| return BO; |
| } |
| |
| #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \ |
| static BinaryOperator *Create ## NUWNSWEXACT ## OPC \ |
| (Value *V1, Value *V2, const Twine &Name = "") { \ |
| return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \ |
| } \ |
| static BinaryOperator *Create ## NUWNSWEXACT ## OPC \ |
| (Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \ |
| return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \ |
| } \ |
| static BinaryOperator *Create ## NUWNSWEXACT ## OPC \ |
| (Value *V1, Value *V2, const Twine &Name, Instruction *I) { \ |
| return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \ |
| } |
| |
| DEFINE_HELPERS(Add, NSW) // CreateNSWAdd |
| DEFINE_HELPERS(Add, NUW) // CreateNUWAdd |
| DEFINE_HELPERS(Sub, NSW) // CreateNSWSub |
| DEFINE_HELPERS(Sub, NUW) // CreateNUWSub |
| DEFINE_HELPERS(Mul, NSW) // CreateNSWMul |
| DEFINE_HELPERS(Mul, NUW) // CreateNUWMul |
| DEFINE_HELPERS(Shl, NSW) // CreateNSWShl |
| DEFINE_HELPERS(Shl, NUW) // CreateNUWShl |
| |
| DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv |
| DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv |
| DEFINE_HELPERS(AShr, Exact) // CreateExactAShr |
| DEFINE_HELPERS(LShr, Exact) // CreateExactLShr |
| |
| #undef DEFINE_HELPERS |
| |
| /// Helper functions to construct and inspect unary operations (NEG and NOT) |
| /// via binary operators SUB and XOR: |
| /// |
| /// CreateNeg, CreateNot - Create the NEG and NOT |
| /// instructions out of SUB and XOR instructions. |
| /// |
| static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| static BinaryOperator *CreateNeg(Value *Op, const Twine &Name, |
| BasicBlock *InsertAtEnd); |
| static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name, |
| BasicBlock *InsertAtEnd); |
| static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name, |
| BasicBlock *InsertAtEnd); |
| static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name, |
| BasicBlock *InsertAtEnd); |
| static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| static BinaryOperator *CreateNot(Value *Op, const Twine &Name, |
| BasicBlock *InsertAtEnd); |
| |
| /// isNeg, isFNeg, isNot - Check if the given Value is a |
| /// NEG, FNeg, or NOT instruction. |
| /// |
| static bool isNeg(const Value *V); |
| static bool isFNeg(const Value *V); |
| static bool isNot(const Value *V); |
| |
| /// getNegArgument, getNotArgument - Helper functions to extract the |
| /// unary argument of a NEG, FNEG or NOT operation implemented via |
| /// Sub, FSub, or Xor. |
| /// |
| static const Value *getNegArgument(const Value *BinOp); |
| static Value *getNegArgument( Value *BinOp); |
| static const Value *getFNegArgument(const Value *BinOp); |
| static Value *getFNegArgument( Value *BinOp); |
| static const Value *getNotArgument(const Value *BinOp); |
| static Value *getNotArgument( Value *BinOp); |
| |
| BinaryOps getOpcode() const { |
| return static_cast<BinaryOps>(Instruction::getOpcode()); |
| } |
| |
| /// swapOperands - Exchange the two operands to this instruction. |
| /// This instruction is safe to use on any binary instruction and |
| /// does not modify the semantics of the instruction. If the instruction |
| /// cannot be reversed (ie, it's a Div), then return true. |
| /// |
| bool swapOperands(); |
| |
| /// setHasNoUnsignedWrap - Set or clear the nsw flag on this instruction, |
| /// which must be an operator which supports this flag. See LangRef.html |
| /// for the meaning of this flag. |
| void setHasNoUnsignedWrap(bool b = true); |
| |
| /// setHasNoSignedWrap - Set or clear the nsw flag on this instruction, |
| /// which must be an operator which supports this flag. See LangRef.html |
| /// for the meaning of this flag. |
| void setHasNoSignedWrap(bool b = true); |
| |
| /// setIsExact - Set or clear the exact flag on this instruction, |
| /// which must be an operator which supports this flag. See LangRef.html |
| /// for the meaning of this flag. |
| void setIsExact(bool b = true); |
| |
| /// hasNoUnsignedWrap - Determine whether the no unsigned wrap flag is set. |
| bool hasNoUnsignedWrap() const; |
| |
| /// hasNoSignedWrap - Determine whether the no signed wrap flag is set. |
| bool hasNoSignedWrap() const; |
| |
| /// isExact - Determine whether the exact flag is set. |
| bool isExact() const; |
| |
| // Methods for support type inquiry through isa, cast, and dyn_cast: |
| static inline bool classof(const BinaryOperator *) { return true; } |
| static inline bool classof(const Instruction *I) { |
| return I->isBinaryOp(); |
| } |
| static inline bool classof(const Value *V) { |
| return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| } |
| }; |
| |
| template <> |
| struct OperandTraits<BinaryOperator> : |
| public FixedNumOperandTraits<BinaryOperator, 2> { |
| }; |
| |
| DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value) |
| |
| //===----------------------------------------------------------------------===// |
| // CastInst Class |
| //===----------------------------------------------------------------------===// |
| |
| /// CastInst - This is the base class for all instructions that perform data |
| /// casts. It is simply provided so that instruction category testing |
| /// can be performed with code like: |
| /// |
| /// if (isa<CastInst>(Instr)) { ... } |
| /// @brief Base class of casting instructions. |
| class CastInst : public UnaryInstruction { |
| protected: |
| /// @brief Constructor with insert-before-instruction semantics for subclasses |
| CastInst(Type *Ty, unsigned iType, Value *S, |
| const Twine &NameStr = "", Instruction *InsertBefore = 0) |
| : UnaryInstruction(Ty, iType, S, InsertBefore) { |
| setName(NameStr); |
| } |
| /// @brief Constructor with insert-at-end-of-block semantics for subclasses |
| CastInst(Type *Ty, unsigned iType, Value *S, |
| const Twine &NameStr, BasicBlock *InsertAtEnd) |
| : UnaryInstruction(Ty, iType, S, InsertAtEnd) { |
| setName(NameStr); |
| } |
| public: |
| /// Provides a way to construct any of the CastInst subclasses using an |
| /// opcode instead of the subclass's constructor. The opcode must be in the |
| /// CastOps category (Instruction::isCast(opcode) returns true). This |
| /// constructor has insert-before-instruction semantics to automatically |
| /// insert the new CastInst before InsertBefore (if it is non-null). |
| /// @brief Construct any of the CastInst subclasses |
| static CastInst *Create( |
| Instruction::CastOps, ///< The opcode of the cast instruction |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which cast should be made |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| /// Provides a way to construct any of the CastInst subclasses using an |
| /// opcode instead of the subclass's constructor. The opcode must be in the |
| /// CastOps category. This constructor has insert-at-end-of-block semantics |
| /// to automatically insert the new CastInst at the end of InsertAtEnd (if |
| /// its non-null). |
| /// @brief Construct any of the CastInst subclasses |
| static CastInst *Create( |
| Instruction::CastOps, ///< The opcode for the cast instruction |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which operand is casted |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Create a ZExt or BitCast cast instruction |
| static CastInst *CreateZExtOrBitCast( |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which cast should be made |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| |
| /// @brief Create a ZExt or BitCast cast instruction |
| static CastInst *CreateZExtOrBitCast( |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which operand is casted |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Create a SExt or BitCast cast instruction |
| static CastInst *CreateSExtOrBitCast( |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which cast should be made |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| |
| /// @brief Create a SExt or BitCast cast instruction |
| static CastInst *CreateSExtOrBitCast( |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which operand is casted |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Create a BitCast or a PtrToInt cast instruction |
| static CastInst *CreatePointerCast( |
| Value *S, ///< The pointer value to be casted (operand 0) |
| Type *Ty, ///< The type to which operand is casted |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Create a BitCast or a PtrToInt cast instruction |
| static CastInst *CreatePointerCast( |
| Value *S, ///< The pointer value to be casted (operand 0) |
| Type *Ty, ///< The type to which cast should be made |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| |
| /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts. |
| static CastInst *CreateIntegerCast( |
| Value *S, ///< The pointer value to be casted (operand 0) |
| Type *Ty, ///< The type to which cast should be made |
| bool isSigned, ///< Whether to regard S as signed or not |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| |
| /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts. |
| static CastInst *CreateIntegerCast( |
| Value *S, ///< The integer value to be casted (operand 0) |
| Type *Ty, ///< The integer type to which operand is casted |
| bool isSigned, ///< Whether to regard S as signed or not |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts |
| static CastInst *CreateFPCast( |
| Value *S, ///< The floating point value to be casted |
| Type *Ty, ///< The floating point type to cast to |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| |
| /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts |
| static CastInst *CreateFPCast( |
| Value *S, ///< The floating point value to be casted |
| Type *Ty, ///< The floating point type to cast to |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Create a Trunc or BitCast cast instruction |
| static CastInst *CreateTruncOrBitCast( |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which cast should be made |
| const Twine &Name = "", ///< Name for the instruction |
| Instruction *InsertBefore = 0 ///< Place to insert the instruction |
| ); |
| |
| /// @brief Create a Trunc or BitCast cast instruction |
| static CastInst *CreateTruncOrBitCast( |
| Value *S, ///< The value to be casted (operand 0) |
| Type *Ty, ///< The type to which operand is casted |
| const Twine &Name, ///< The name for the instruction |
| BasicBlock *InsertAtEnd ///< The block to insert the instruction into |
| ); |
| |
| /// @brief Check whether it is valid to call getCastOpcode for these types. |
| static bool isCastable( |
| Type *SrcTy, ///< The Type from which the value should be cast. |
| Type *DestTy ///< The Type to which the value should be cast. |
| ); |
| |
| /// Returns the opcode necessary to cast Val into Ty using usual casting |
| /// rules. |
| /// @brief Infer the opcode for cast operand and type |
| static Instruction::CastOps getCastOpcode( |
| const Value *Val, ///< The value to cast |
| bool SrcIsSigned, ///< Whether to treat the source as signed |
| Type *Ty, ///< The Type to which the value should be casted |
| bool DstIsSigned ///< Whether to treate the dest. as signed |
| ); |
| |
| /// There are several places where we need to know if a cast instruction |
| /// only deals with integer source and destination types. To simplify that |
| /// logic, this method is provided. |
| /// @returns true iff the cast has only integral typed operand and dest type. |
| /// @brief Determine if this is an integer-only cast. |
| bool isIntegerCast() const; |
| |
| /// A lossless cast is one that does not alter the basic value. It implies |
| /// a no-op cast but is more stringent, preventing things like int->float, |
| /// long->double, or int->ptr. |
| /// @returns true iff the cast is lossless. |
| /// @brief Determine if this is a lossless cast. |
| bool isLosslessCast() const; |
| |
| /// A no-op cast is one that can be effected without changing any bits. |
| /// It implies that the source and destination types are the same size. The |
| /// IntPtrTy argument is used to make accurate determinations for casts |
| /// involving Integer and Pointer types. They are no-op casts if the integer |
| /// is the same size as the pointer. However, pointer size varies with |
| /// platform. Generally, the result of TargetData::getIntPtrType() should be |
| /// passed in. If that's not available, use Type::Int64Ty, which will make |
| /// the isNoopCast call conservative. |
| /// @brief Determine if the described cast is a no-op cast. |
| static bool isNoopCast( |
| Instruction::CastOps Opcode, ///< Opcode of cast |
| Type *SrcTy, ///< SrcTy of cast |
| Type *DstTy, ///< DstTy of cast |
| Type *IntPtrTy ///< Integer type corresponding to Ptr types, or null |
| ); |
| |
| /// @brief Determine if this cast is a no-op cast. |
| bool isNoopCast( |
| Type *IntPtrTy ///< Integer type corresponding to pointer |
| ) const; |
| |
| /// Determine how a pair of casts can be eliminated, if they can be at all. |
| /// This is a helper function for both CastInst and ConstantExpr. |
| /// @returns 0 if the CastInst pair can't be eliminated |
| /// @returns Instruction::CastOps value for a cast that can replace |
| /// the pair, casting SrcTy to DstTy. |
| /// @brief Determine if a cast pair is eliminable |
| static unsigned isEliminableCastPair( |
| Instruction::CastOps firstOpcode, ///< Opcode of first cast |
| Instruction::CastOps secondOpcode, ///< Opcode of second cast |
| Type *SrcTy, ///< SrcTy of 1st cast |
| Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast |
| Type *DstTy, ///< DstTy of 2nd cast |
| Type *IntPtrTy ///< Integer type corresponding to Ptr types, or null |
| ); |
| |
| /// @brief Return the opcode of this CastInst |
| Instruction::CastOps getOpcode() const { |
| return Instruction::CastOps(Instruction::getOpcode()); |
| } |
| |
| /// @brief Return the source type, as a convenience |
| Type* getSrcTy() const { return getOperand(0)->getType(); } |
| /// @brief Return the destination type, as a convenience |
| Type* getDestTy() const { return getType(); } |
| |
| /// This method can be used to determine if a cast from S to DstTy using |
| /// Opcode op is valid or not. |
| /// @returns true iff the proposed cast is valid. |
| /// @brief Determine if a cast is valid without creating one. |
| static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy); |
| |
| /// @brief Methods for support type inquiry through isa, cast, and dyn_cast: |
| static inline bool classof(const CastInst *) { return true; } |
| static inline bool classof(const Instruction *I) { |
| return I->isCast(); |
| } |
| static inline bool classof(const Value *V) { |
| return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| } |
| }; |
| |
| //===----------------------------------------------------------------------===// |
| // CmpInst Class |
| //===----------------------------------------------------------------------===// |
| |
| /// This class is the base class for the comparison instructions. |
| /// @brief Abstract base class of comparison instructions. |
| class CmpInst : public Instruction { |
| void *operator new(size_t, unsigned); // DO NOT IMPLEMENT |
| CmpInst(); // do not implement |
| protected: |
| CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred, |
| Value *LHS, Value *RHS, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| |
| CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred, |
| Value *LHS, Value *RHS, const Twine &Name, |
| BasicBlock *InsertAtEnd); |
| |
| virtual void Anchor() const; // Out of line virtual method. |
| public: |
| /// This enumeration lists the possible predicates for CmpInst subclasses. |
| /// Values in the range 0-31 are reserved for FCmpInst, while values in the |
| /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the |
| /// predicate values are not overlapping between the classes. |
| enum Predicate { |
| // Opcode U L G E Intuitive operation |
| FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded) |
| FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal |
| FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than |
| FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal |
| FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than |
| FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal |
| FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal |
| FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans) |
| FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y) |
| FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal |
| FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than |
| FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal |
| FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than |
| FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal |
| FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal |
| FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded) |
| FIRST_FCMP_PREDICATE = FCMP_FALSE, |
| LAST_FCMP_PREDICATE = FCMP_TRUE, |
| BAD_FCMP_PREDICATE = FCMP_TRUE + 1, |
| ICMP_EQ = 32, ///< equal |
| ICMP_NE = 33, ///< not equal |
| ICMP_UGT = 34, ///< unsigned greater than |
| ICMP_UGE = 35, ///< unsigned greater or equal |
| ICMP_ULT = 36, ///< unsigned less than |
| ICMP_ULE = 37, ///< unsigned less or equal |
| ICMP_SGT = 38, ///< signed greater than |
| ICMP_SGE = 39, ///< signed greater or equal |
| ICMP_SLT = 40, ///< signed less than |
| ICMP_SLE = 41, ///< signed less or equal |
| FIRST_ICMP_PREDICATE = ICMP_EQ, |
| LAST_ICMP_PREDICATE = ICMP_SLE, |
| BAD_ICMP_PREDICATE = ICMP_SLE + 1 |
| }; |
| |
| // allocate space for exactly two operands |
| void *operator new(size_t s) { |
| return User::operator new(s, 2); |
| } |
| /// Construct a compare instruction, given the opcode, the predicate and |
| /// the two operands. Optionally (if InstBefore is specified) insert the |
| /// instruction into a BasicBlock right before the specified instruction. |
| /// The specified Instruction is allowed to be a dereferenced end iterator. |
| /// @brief Create a CmpInst |
| static CmpInst *Create(OtherOps Op, |
| unsigned short predicate, Value *S1, |
| Value *S2, const Twine &Name = "", |
| Instruction *InsertBefore = 0); |
| |
| /// Construct a compare instruction, given the opcode, the predicate and the |
| /// two operands. Also automatically insert this instruction to the end of |
| /// the BasicBlock specified. |
| /// @brief Create a CmpInst |
| static CmpInst *Create(OtherOps Op, unsigned short predicate, Value *S1, |
| Value *S2, const Twine &Name, BasicBlock *InsertAtEnd); |
| |
| /// @brief Get the opcode casted to the right type |
| OtherOps getOpcode() const { |
| return static_cast<OtherOps>(Instruction::getOpcode()); |
| } |
| |
| /// @brief Return the predicate for this instruction. |
| Predicate getPredicate() const { |
| return Predicate(getSubclassDataFromInstruction()); |
| } |
| |
| /// @brief Set the predicate for this instruction to the specified value. |
| void setPredicate(Predicate P) { setInstructionSubclassData(P); } |
| |
| static bool isFPPredicate(Predicate P) { |
| return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE; |
| } |
| |
| static bool isIntPredicate(Predicate P) { |
| return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE; |
| } |
| |
| bool isFPPredicate() const { return isFPPredicate(getPredicate()); } |
| bool isIntPredicate() const { return isIntPredicate(getPredicate()); } |
| |
| |
| /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, |
| /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. |
| /// @returns the inverse predicate for the instruction's current predicate. |
| /// @brief Return the inverse of the instruction's predicate. |
| Predicate getInversePredicate() const { |
| return getInversePredicate(getPredicate()); |
| } |
| |
| /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, |
| /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. |
| /// @returns the inverse predicate for predicate provided in \p pred. |
| /// @brief Return the inverse of a given predicate |
| static Predicate getInversePredicate(Predicate pred); |
| |
| /// For example, EQ->EQ, SLE->SGE, ULT->UGT, |
| /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc. |
| /// @returns the predicate that would be the result of exchanging the two |
| /// operands of the CmpInst instruction without changing the result |
| /// produced. |
| /// @brief Return the predicate as if the operands were swapped |
| Predicate getSwappedPredicate() const { |
| return getSwappedPredicate(getPredicate()); |
| } |
| |
| /// This is a static version that you can use without an instruction |
| /// available. |
| /// @brief Return the predicate as if the operands were swapped. |
| static Predicate getSwappedPredicate(Predicate pred); |
| |
| /// @brief Provide more efficient getOperand methods. |
| DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); |
| |
| /// This is just a convenience that dispatches to the subclasses. |
| /// @brief Swap the operands and adjust predicate accordingly to retain |
| /// the same comparison. |
| void swapOperands(); |
| |
| /// This is just a convenience that dispatches to the subclasses. |
| /// @brief Determine if this CmpInst is commutative. |
| bool isCommutative() const; |
| |
| /// This is just a convenience that dispatches to the subclasses. |
| /// @brief Determine if this is an equals/not equals predicate. |
| bool isEquality() const; |
| |
| /// @returns true if the comparison is signed, false otherwise. |
| /// @brief Determine if this instruction is using a signed comparison. |
| bool isSigned() const { |
| return isSigned(getPredicate()); |
| } |
| |
| /// @returns true if the comparison is unsigned, false otherwise. |
| /// @brief Determine if this instruction is using an unsigned comparison. |
| bool isUnsigned() const { |
| return isUnsigned(getPredicate()); |
| } |
| |
| /// This is just a convenience. |
| /// @brief Determine if this is true when both operands are the same. |
| bool isTrueWhenEqual() const { |
| return isTrueWhenEqual(getPredicate()); |
| } |
| |
| /// This is just a convenience. |
| /// @brief Determine if this is false when both operands are the same. |
| bool isFalseWhenEqual() const { |
| return isFalseWhenEqual(getPredicate()); |
| } |
| |
| /// @returns true if the predicate is unsigned, false otherwise. |
| /// @brief Determine if the predicate is an unsigned operation. |
| static bool isUnsigned(unsigned short predicate); |
| |
| /// @returns true if the predicate is signed, false otherwise. |
| /// @brief Determine if the predicate is an signed operation. |
| static bool isSigned(unsigned short predicate); |
| |
| /// @brief Determine if the predicate is an ordered operation. |
| static bool isOrdered(unsigned short predicate); |
| |
| /// @brief Determine if the predicate is an unordered operation. |
| static bool isUnordered(unsigned short predicate); |
| |
| /// Determine if the predicate is true when comparing a value with itself. |
| static bool isTrueWhenEqual(unsigned short predicate); |
| |
| /// Determine if the predicate is false when comparing a value with itself. |
| static bool isFalseWhenEqual(unsigned short predicate); |
| |
| /// @brief Methods for support type inquiry through isa, cast, and dyn_cast: |
| static inline bool classof(const CmpInst *) { return true; } |
| static inline bool classof(const Instruction *I) { |
| return I->getOpcode() == Instruction::ICmp || |
| I->getOpcode() == Instruction::FCmp; |
| } |
| static inline bool classof(const Value *V) { |
| return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| } |
| |
| /// @brief Create a result type for fcmp/icmp |
| static Type* makeCmpResultType(Type* opnd_type) { |
| if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) { |
| return VectorType::get(Type::getInt1Ty(opnd_type->getContext()), |
| vt->getNumElements()); |
| } |
| return Type::getInt1Ty(opnd_type->getContext()); |
| } |
| private: |
| // Shadow Value::setValueSubclassData with a private forwarding method so that |
| // subclasses cannot accidentally use it. |
| void setValueSubclassData(unsigned short D) { |
| Value::setValueSubclassData(D); |
| } |
| }; |
| |
| |
| // FIXME: these are redundant if CmpInst < BinaryOperator |
| template <> |
| struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> { |
| }; |
| |
| DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value) |
| |
| } // End llvm namespace |
| |
| #endif |