Changes in directory llvm/include/llvm:
Constants.h updated: 1.111 -> 1.112 InstrTypes.h updated: 1.55 -> 1.56 Instruction.def updated: 1.27 -> 1.28 Instruction.h updated: 1.76 -> 1.77 Instructions.h updated: 1.47 -> 1.48 Pass.h updated: 1.66 -> 1.67 --- Log message: For PR950: http://llvm.org/PR950 : This patch removes the SetCC instructions and replaces them with the ICmp and FCmp instructions. The SetCondInst instruction has been removed and been replaced with ICmpInst and FCmpInst. --- Diffs of the changes: (+96 -134) Constants.h | 13 +------ InstrTypes.h | 14 +++++++ Instruction.def | 86 ++++++++++++++++++++++-------------------------- Instruction.h | 16 +++++---- Instructions.h | 99 ++++++++++++++++---------------------------------------- Pass.h | 2 - 6 files changed, 96 insertions(+), 134 deletions(-) Index: llvm/include/llvm/Constants.h diff -u llvm/include/llvm/Constants.h:1.111 llvm/include/llvm/Constants.h:1.112 --- llvm/include/llvm/Constants.h:1.111 Mon Dec 18 19:34:39 2006 +++ llvm/include/llvm/Constants.h Sat Dec 23 00:05:40 2006 @@ -496,8 +496,8 @@ // ConstantExprs in intermediate forms. static Constant *getTy(const Type *Ty, unsigned Opcode, Constant *C1, Constant *C2); - static Constant *getCompareTy(unsigned Opcode, unsigned short pred, - Constant *C1, Constant *C2); + static Constant *getCompareTy(unsigned short pred, Constant *C1, + Constant *C2); static Constant *getShiftTy(const Type *Ty, unsigned Opcode, Constant *C1, Constant *C2); static Constant *getSelectTy(const Type *Ty, @@ -604,8 +604,7 @@ static Constant *get(unsigned Opcode, Constant *C1, Constant *C2); /// @brief Return an ICmp or FCmp comparison operator constant expression. - static Constant *getCompare(unsigned Opcode, unsigned short pred, - Constant *C1, Constant *C2); + static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2); /// ConstantExpr::get* - Return some common constants without having to /// specify the full Instruction::OPCODE identifier. @@ -624,12 +623,6 @@ static Constant *getAnd(Constant *C1, Constant *C2); static Constant *getOr(Constant *C1, Constant *C2); static Constant *getXor(Constant *C1, Constant *C2); - static Constant *getSetEQ(Constant *C1, Constant *C2); - static Constant *getSetNE(Constant *C1, Constant *C2); - static Constant *getSetLT(Constant *C1, Constant *C2); - static Constant *getSetGT(Constant *C1, Constant *C2); - static Constant *getSetLE(Constant *C1, Constant *C2); - static Constant *getSetGE(Constant *C1, Constant *C2); static Constant* getICmp(unsigned short pred, Constant* LHS, Constant* RHS); static Constant* getFCmp(unsigned short pred, Constant* LHS, Constant* RHS); static Constant *getShl(Constant *C1, Constant *C2); Index: llvm/include/llvm/InstrTypes.h diff -u llvm/include/llvm/InstrTypes.h:1.55 llvm/include/llvm/InstrTypes.h:1.56 --- llvm/include/llvm/InstrTypes.h:1.55 Mon Dec 18 02:52:59 2006 +++ llvm/include/llvm/InstrTypes.h Sat Dec 23 00:05:40 2006 @@ -543,6 +543,20 @@ /// @brief Determine if this is an equals/not equals predicate. bool isEquality(); + /// @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); + /// @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) { Index: llvm/include/llvm/Instruction.def diff -u llvm/include/llvm/Instruction.def:1.27 llvm/include/llvm/Instruction.def:1.28 --- llvm/include/llvm/Instruction.def:1.27 Wed Nov 29 15:37:00 2006 +++ llvm/include/llvm/Instruction.def Sat Dec 23 00:05:40 2006 @@ -118,61 +118,53 @@ HANDLE_BINARY_INST(16, And , BinaryOperator) HANDLE_BINARY_INST(17, Or , BinaryOperator) HANDLE_BINARY_INST(18, Xor , BinaryOperator) - -// Binary comparison operators... -HANDLE_BINARY_INST(19, SetEQ , SetCondInst) -HANDLE_BINARY_INST(20, SetNE , SetCondInst) -HANDLE_BINARY_INST(21, SetLE , SetCondInst) -HANDLE_BINARY_INST(22, SetGE , SetCondInst) -HANDLE_BINARY_INST(23, SetLT , SetCondInst) -HANDLE_BINARY_INST(24, SetGT , SetCondInst) - LAST_BINARY_INST(24) + LAST_BINARY_INST(18) // Memory operators... - FIRST_MEMORY_INST(25) -HANDLE_MEMORY_INST(25, Malloc, MallocInst) // Heap management instructions -HANDLE_MEMORY_INST(26, Free , FreeInst ) -HANDLE_MEMORY_INST(27, Alloca, AllocaInst) // Stack management -HANDLE_MEMORY_INST(28, Load , LoadInst ) // Memory manipulation instrs -HANDLE_MEMORY_INST(29, Store , StoreInst ) -HANDLE_MEMORY_INST(30, GetElementPtr, GetElementPtrInst) - LAST_MEMORY_INST(30) + FIRST_MEMORY_INST(19) +HANDLE_MEMORY_INST(19, Malloc, MallocInst) // Heap management instructions +HANDLE_MEMORY_INST(20, Free , FreeInst ) +HANDLE_MEMORY_INST(21, Alloca, AllocaInst) // Stack management +HANDLE_MEMORY_INST(22, Load , LoadInst ) // Memory manipulation instrs +HANDLE_MEMORY_INST(23, Store , StoreInst ) +HANDLE_MEMORY_INST(24, GetElementPtr, GetElementPtrInst) + LAST_MEMORY_INST(24) // Cast operators ... // NOTE: The order matters here because CastInst::isEliminableCastPair // NOTE: (see Instructions.cpp) encodes a table based on this ordering. - FIRST_CAST_INST(31) -HANDLE_CAST_INST(31, Trunc , TruncInst ) // Truncate integers -HANDLE_CAST_INST(32, ZExt , ZExtInst ) // Zero extend integers -HANDLE_CAST_INST(33, SExt , SExtInst ) // Sign extend integers -HANDLE_CAST_INST(34, FPToUI , FPToUIInst ) // floating point -> UInt -HANDLE_CAST_INST(35, FPToSI , FPToSIInst ) // floating point -> SInt -HANDLE_CAST_INST(36, UIToFP , UIToFPInst ) // UInt -> floating point -HANDLE_CAST_INST(37, SIToFP , SIToFPInst ) // SInt -> floating point -HANDLE_CAST_INST(38, FPTrunc , FPTruncInst ) // Truncate floating point -HANDLE_CAST_INST(39, FPExt , FPExtInst ) // Extend floating point -HANDLE_CAST_INST(40, PtrToInt, PtrToIntInst) // Pointer -> Integer -HANDLE_CAST_INST(41, IntToPtr, IntToPtrInst) // Integer -> Pointer -HANDLE_CAST_INST(42, BitCast , BitCastInst ) // Type cast - LAST_CAST_INST(42) + FIRST_CAST_INST(25) +HANDLE_CAST_INST(25, Trunc , TruncInst ) // Truncate integers +HANDLE_CAST_INST(26, ZExt , ZExtInst ) // Zero extend integers +HANDLE_CAST_INST(27, SExt , SExtInst ) // Sign extend integers +HANDLE_CAST_INST(28, FPToUI , FPToUIInst ) // floating point -> UInt +HANDLE_CAST_INST(29, FPToSI , FPToSIInst ) // floating point -> SInt +HANDLE_CAST_INST(30, UIToFP , UIToFPInst ) // UInt -> floating point +HANDLE_CAST_INST(31, SIToFP , SIToFPInst ) // SInt -> floating point +HANDLE_CAST_INST(32, FPTrunc , FPTruncInst ) // Truncate floating point +HANDLE_CAST_INST(33, FPExt , FPExtInst ) // Extend floating point +HANDLE_CAST_INST(34, PtrToInt, PtrToIntInst) // Pointer -> Integer +HANDLE_CAST_INST(35, IntToPtr, IntToPtrInst) // Integer -> Pointer +HANDLE_CAST_INST(36, BitCast , BitCastInst ) // Type cast + LAST_CAST_INST(36) // Other operators... - FIRST_OTHER_INST(43) -HANDLE_OTHER_INST(43, ICmp , ICmpInst ) // Integer comparison instruction -HANDLE_OTHER_INST(44, FCmp , FCmpInst ) // Floating point comparison instr. -HANDLE_OTHER_INST(45, PHI , PHINode ) // PHI node instruction -HANDLE_OTHER_INST(46, Call , CallInst ) // Call a function -HANDLE_OTHER_INST(47, Shl , ShiftInst ) // Shift Left operations (logical) -HANDLE_OTHER_INST(48, LShr , ShiftInst ) // Logical Shift right (unsigned) -HANDLE_OTHER_INST(49, AShr , ShiftInst ) // Arithmetic shift right (signed) -HANDLE_OTHER_INST(50, Select , SelectInst ) // select instruction -HANDLE_OTHER_INST(51, UserOp1, Instruction) // May be used internally in a pass -HANDLE_OTHER_INST(52, UserOp2, Instruction) // Internal to passes only -HANDLE_OTHER_INST(53, VAArg , VAArgInst ) // vaarg instruction -HANDLE_OTHER_INST(54, ExtractElement, ExtractElementInst)// extract from vector. -HANDLE_OTHER_INST(55, InsertElement, InsertElementInst) // insert into vector -HANDLE_OTHER_INST(56, ShuffleVector, ShuffleVectorInst) // shuffle two vectors. - LAST_OTHER_INST(56) + FIRST_OTHER_INST(37) +HANDLE_OTHER_INST(37, ICmp , ICmpInst ) // Integer comparison instruction +HANDLE_OTHER_INST(38, FCmp , FCmpInst ) // Floating point comparison instr. +HANDLE_OTHER_INST(39, PHI , PHINode ) // PHI node instruction +HANDLE_OTHER_INST(40, Call , CallInst ) // Call a function +HANDLE_OTHER_INST(41, Shl , ShiftInst ) // Shift Left operations (logical) +HANDLE_OTHER_INST(42, LShr , ShiftInst ) // Logical Shift right (unsigned) +HANDLE_OTHER_INST(43, AShr , ShiftInst ) // Arithmetic shift right (signed) +HANDLE_OTHER_INST(44, Select , SelectInst ) // select instruction +HANDLE_OTHER_INST(45, UserOp1, Instruction) // May be used internally in a pass +HANDLE_OTHER_INST(46, UserOp2, Instruction) // Internal to passes only +HANDLE_OTHER_INST(47, VAArg , VAArgInst ) // vaarg instruction +HANDLE_OTHER_INST(48, ExtractElement, ExtractElementInst)// extract from vector. +HANDLE_OTHER_INST(49, InsertElement, InsertElementInst) // insert into vector +HANDLE_OTHER_INST(50, ShuffleVector, ShuffleVectorInst) // shuffle two vectors. + LAST_OTHER_INST(50) #undef FIRST_TERM_INST #undef HANDLE_TERM_INST Index: llvm/include/llvm/Instruction.h diff -u llvm/include/llvm/Instruction.h:1.76 llvm/include/llvm/Instruction.h:1.77 --- llvm/include/llvm/Instruction.h:1.76 Sat Dec 16 23:15:12 2006 +++ llvm/include/llvm/Instruction.h Sat Dec 23 00:05:40 2006 @@ -71,6 +71,16 @@ /// extra information (e.g. load is volatile) agree. bool isIdenticalTo(Instruction *I) const; + /// This function determines if the specified instruction executes the same + /// operation as the current one. This means that the opcodes, type, operand + /// types and any other factors affecting the operation must be the same. This + /// is similar to isIdenticalTo except the operands themselves don't have to + /// be identical. + /// @returns true if the specified instruction is the same operation as + /// the current one. + /// @brief Determine if one instruction is the same operation as another. + bool isSameOperationAs(Instruction *I) const; + /// use_back - Specialize the methods defined in Value, as we know that an /// instruction can only be used by other instructions. Instruction *use_back() { return cast<Instruction>(*use_begin());} @@ -155,12 +165,6 @@ bool isCommutative() const { return isCommutative(getOpcode()); } static bool isCommutative(unsigned op); - /// isComparison - Return true if the instruction is a Set* instruction: - /// - bool isComparison() const { return isComparison(getOpcode()); } - static bool isComparison(unsigned op); - - /// isTrappingInstruction - Return true if the instruction may trap. /// bool isTrapping() const { Index: llvm/include/llvm/Instructions.h diff -u llvm/include/llvm/Instructions.h:1.47 llvm/include/llvm/Instructions.h:1.48 --- llvm/include/llvm/Instructions.h:1.47 Sun Nov 26 19:05:09 2006 +++ llvm/include/llvm/Instructions.h Sat Dec 23 00:05:40 2006 @@ -440,7 +440,8 @@ ICMP_SLT = 40, ///< signed less than ICMP_SLE = 41, ///< signed less or equal FIRST_ICMP_PREDICATE = ICMP_EQ, - LAST_ICMP_PREDICATE = ICMP_SLE + LAST_ICMP_PREDICATE = ICMP_SLE, + BAD_ICMP_PREDICATE = ICMP_SLE + 1 }; /// @brief Constructor with insert-before-instruction semantics. @@ -490,16 +491,30 @@ /// 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 Opcode); + static Predicate getSwappedPredicate(Predicate pred); + + /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc. + /// @returns the predicate that would be the result if the operand were + /// regarded as signed. + /// @brief Return the signed version of the predicate + Predicate getSignedPredicate() const { + return getSignedPredicate(getPredicate()); + } + + /// This is a static version that you can use without an instruction. + /// @brief Return the signed version of the predicate. + static Predicate getSignedPredicate(Predicate pred); /// This also tests for commutativity. If isEquality() returns true then - /// the predicate is also commutative. Only the equality predicates are - /// commutative. + /// the predicate is also commutative. /// @returns true if the predicate of this instruction is EQ or NE. /// @brief Determine if this is an equality predicate. bool isEquality() const { return SubclassData == ICMP_EQ || SubclassData == ICMP_NE; } + + /// @returns true if the predicate of this ICmpInst is commutative + /// @brief Determine if this relation is commutative. bool isCommutative() const { return isEquality(); } /// @returns true if the predicate is relational (not EQ or NE). @@ -508,6 +523,14 @@ return !isEquality(); } + /// @returns true if the predicate of this ICmpInst is signed, false otherwise + /// @brief Determine if this instruction's predicate is signed. + bool isSignedPredicate() { return isSignedPredicate(getPredicate()); } + + /// @returns true if the predicate provided is signed, false otherwise + /// @brief Determine if the predicate is signed. + static bool isSignedPredicate(Predicate pred); + /// Exchange the two operands to this instruction in such a way that it does /// not modify the semantics of the instruction. The predicate value may be /// changed to retain the same result if the predicate is order dependent @@ -559,7 +582,8 @@ 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 + LAST_FCMP_PREDICATE = FCMP_TRUE, + BAD_FCMP_PREDICATE = FCMP_TRUE + 1 }; /// @brief Constructor with insert-before-instruction semantics. @@ -646,71 +670,6 @@ } }; - -//===----------------------------------------------------------------------===// -// SetCondInst Class -//===----------------------------------------------------------------------===// - -/// SetCondInst class - Represent a setCC operator, where CC is eq, ne, lt, gt, -/// le, or ge. -/// -class SetCondInst : public BinaryOperator { -public: - SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS, - const std::string &Name = "", Instruction *InsertBefore = 0); - SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS, - const std::string &Name, BasicBlock *InsertAtEnd); - - /// getInverseCondition - Return the inverse of the current condition opcode. - /// For example seteq -> setne, setgt -> setle, setlt -> setge, etc... - /// - BinaryOps getInverseCondition() const { - return getInverseCondition(getOpcode()); - } - - /// getInverseCondition - Static version that you can use without an - /// instruction available. - /// - static BinaryOps getInverseCondition(BinaryOps Opcode); - - /// getSwappedCondition - Return the condition opcode that would be the result - /// of exchanging the two operands of the setcc instruction without changing - /// the result produced. Thus, seteq->seteq, setle->setge, setlt->setgt, etc. - /// - BinaryOps getSwappedCondition() const { - return getSwappedCondition(getOpcode()); - } - - /// getSwappedCondition - Static version that you can use without an - /// instruction available. - /// - static BinaryOps getSwappedCondition(BinaryOps Opcode); - - /// isEquality - Return true if this comparison is an ==/!= comparison. - /// - bool isEquality() const { - return getOpcode() == SetEQ || getOpcode() == SetNE; - } - - /// isRelational - Return true if this comparison is a </>/<=/>= comparison. - /// - bool isRelational() const { - return !isEquality(); - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const SetCondInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == SetEQ || I->getOpcode() == SetNE || - I->getOpcode() == SetLE || I->getOpcode() == SetGE || - I->getOpcode() == SetLT || I->getOpcode() == SetGT; - } - static inline bool classof(const Value *V) { - return isa<Instruction>(V) && classof(cast<Instruction>(V)); - } -}; - - //===----------------------------------------------------------------------===// // CallInst Class //===----------------------------------------------------------------------===// Index: llvm/include/llvm/Pass.h diff -u llvm/include/llvm/Pass.h:1.66 llvm/include/llvm/Pass.h:1.67 --- llvm/include/llvm/Pass.h:1.66 Fri Dec 22 16:55:30 2006 +++ llvm/include/llvm/Pass.h Sat Dec 23 00:05:40 2006 @@ -36,7 +36,7 @@ #include <typeinfo> #include <cassert> -//#define USE_OLD_PASSMANAGER 1 +#define USE_OLD_PASSMANAGER 1 namespace llvm { _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits