From 0b16ae209a1d0876a7ea6800bb567d925443cba3 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 13 Oct 2002 19:39:16 +0000 Subject: [PATCH] - Rename Instruction::First*Op to *OpsBegin, and Num*Ops to *OpsEnd to reflect the fact that it's a range being defined. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4147 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/InstrTypes.h | 4 ++-- include/llvm/Instruction.h | 20 +++++++++---------- lib/Bytecode/Reader/InstructionReader.cpp | 4 ++-- lib/Target/SparcV9/SparcV9InstrInfo.cpp | 16 +++++++-------- lib/Target/SparcV9/SparcV9PreSelection.cpp | 4 ++-- .../Instrumentation/TraceValues.cpp | 2 +- lib/VMCore/BasicBlock.cpp | 4 ++-- lib/VMCore/Constants.cpp | 4 ++-- 8 files changed, 29 insertions(+), 29 deletions(-) diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h index fc1917b10be..09c08b8342a 100644 --- a/include/llvm/InstrTypes.h +++ b/include/llvm/InstrTypes.h @@ -47,7 +47,7 @@ public: // 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->getOpcode() >= FirstTermOp && I->getOpcode() < NumTermOps; + return I->getOpcode() >= TermOpsBegin && I->getOpcode() < TermOpsEnd; } static inline bool classof(const Value *V) { return isa(V) && classof(cast(V)); @@ -120,7 +120,7 @@ public: // 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->getOpcode() >= FirstBinaryOp && I->getOpcode() < NumBinaryOps; + return I->getOpcode() >= BinaryOpsBegin && I->getOpcode() < BinaryOpsEnd; } static inline bool classof(const Value *V) { return isa(V) && classof(cast(V)); diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h index 0674f0ed1ab..89c64098c3c 100644 --- a/include/llvm/Instruction.h +++ b/include/llvm/Instruction.h @@ -68,10 +68,10 @@ public: static const char* getOpcodeName(unsigned OpCode); inline bool isTerminator() const { // Instance of TerminatorInst? - return iType >= FirstTermOp && iType < NumTermOps; + return iType >= TermOpsBegin && iType < TermOpsEnd; } inline bool isBinaryOp() const { - return iType >= FirstBinaryOp && iType < NumBinaryOps; + return iType >= BinaryOpsBegin && iType < BinaryOpsEnd; } virtual void print(std::ostream &OS) const; @@ -86,30 +86,30 @@ public: // Exported enumerations... // enum TermOps { // These terminate basic blocks -#define FIRST_TERM_INST(N) FirstTermOp = N, +#define FIRST_TERM_INST(N) TermOpsBegin = N, #define HANDLE_TERM_INST(N, OPC, CLASS) OPC = N, -#define LAST_TERM_INST(N) NumTermOps = N+1, +#define LAST_TERM_INST(N) TermOpsEnd = N+1, #include "llvm/Instruction.def" }; enum BinaryOps { -#define FIRST_BINARY_INST(N) FirstBinaryOp = N, +#define FIRST_BINARY_INST(N) BinaryOpsBegin = N, #define HANDLE_BINARY_INST(N, OPC, CLASS) OPC = N, -#define LAST_BINARY_INST(N) NumBinaryOps = N+1, +#define LAST_BINARY_INST(N) BinaryOpsEnd = N+1, #include "llvm/Instruction.def" }; enum MemoryOps { -#define FIRST_MEMORY_INST(N) FirstMemoryOp = N, +#define FIRST_MEMORY_INST(N) MemoryOpsBegin = N, #define HANDLE_MEMORY_INST(N, OPC, CLASS) OPC = N, -#define LAST_MEMORY_INST(N) NumMemoryOps = N+1, +#define LAST_MEMORY_INST(N) MemoryOpsEnd = N+1, #include "llvm/Instruction.def" }; enum OtherOps { -#define FIRST_OTHER_INST(N) FirstOtherOp = N, +#define FIRST_OTHER_INST(N) OtherOpsBegin = N, #define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N, -#define LAST_OTHER_INST(N) NumOtherOps = N+1, +#define LAST_OTHER_INST(N) OtherOpsEnd = N+1, #include "llvm/Instruction.def" }; }; diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp index 40360991f5c..a4750b0e590 100644 --- a/lib/Bytecode/Reader/InstructionReader.cpp +++ b/lib/Bytecode/Reader/InstructionReader.cpp @@ -122,8 +122,8 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf, if (ParseRawInst(Buf, EndBuf, Raw)) return true; - if (Raw.Opcode >= Instruction::FirstBinaryOp && - Raw.Opcode < Instruction::NumBinaryOps && Raw.NumOperands == 2) { + if (Raw.Opcode >= Instruction::BinaryOpsBegin && + Raw.Opcode < Instruction::BinaryOpsEnd && Raw.NumOperands == 2) { Res = BinaryOperator::create((Instruction::BinaryOps)Raw.Opcode, getValue(Raw.Ty, Raw.Arg1), getValue(Raw.Ty, Raw.Arg2)); diff --git a/lib/Target/SparcV9/SparcV9InstrInfo.cpp b/lib/Target/SparcV9/SparcV9InstrInfo.cpp index 148b76ef5a0..662c80a3577 100644 --- a/lib/Target/SparcV9/SparcV9InstrInfo.cpp +++ b/lib/Target/SparcV9/SparcV9InstrInfo.cpp @@ -266,15 +266,15 @@ CreateIntSetInstruction(const TargetMachine& target, // Entry == 0 ==> no immediate constant field exists at all. // Entry > 0 ==> abs(immediate constant) <= Entry // -vector MaxConstantsTable(Instruction::NumOtherOps); +vector MaxConstantsTable(Instruction::OtherOpsEnd); static int MaxConstantForInstr(unsigned llvmOpCode) { int modelOpCode = -1; - if (llvmOpCode >= Instruction::FirstBinaryOp && - llvmOpCode < Instruction::NumBinaryOps) + if (llvmOpCode >= Instruction::BinaryOpsBegin && + llvmOpCode < Instruction::BinaryOpsEnd) modelOpCode = ADD; else switch(llvmOpCode) { @@ -300,15 +300,15 @@ static void InitializeMaxConstantsTable() { unsigned op; - assert(MaxConstantsTable.size() == Instruction::NumOtherOps && + assert(MaxConstantsTable.size() == Instruction::OtherOpsEnd && "assignments below will be illegal!"); - for (op = Instruction::FirstTermOp; op < Instruction::NumTermOps; ++op) + for (op = Instruction::TermOpsBegin; op < Instruction::TermOpsEnd; ++op) MaxConstantsTable[op] = MaxConstantForInstr(op); - for (op = Instruction::FirstBinaryOp; op < Instruction::NumBinaryOps; ++op) + for (op = Instruction::BinaryOpsBegin; op < Instruction::BinaryOpsEnd; ++op) MaxConstantsTable[op] = MaxConstantForInstr(op); - for (op = Instruction::FirstMemoryOp; op < Instruction::NumMemoryOps; ++op) + for (op = Instruction::MemoryOpsBegin; op < Instruction::MemoryOpsEnd; ++op) MaxConstantsTable[op] = MaxConstantForInstr(op); - for (op = Instruction::FirstOtherOp; op < Instruction::NumOtherOps; ++op) + for (op = Instruction::OtherOpsBegin; op < Instruction::OtherOpsEnd; ++op) MaxConstantsTable[op] = MaxConstantForInstr(op); } diff --git a/lib/Target/SparcV9/SparcV9PreSelection.cpp b/lib/Target/SparcV9/SparcV9PreSelection.cpp index 916938dabec..56c34edbb7f 100644 --- a/lib/Target/SparcV9/SparcV9PreSelection.cpp +++ b/lib/Target/SparcV9/SparcV9PreSelection.cpp @@ -214,8 +214,8 @@ static Instruction* DecomposeConstantExpr(ConstantExpr* CE, "constantGEP", &insertBefore); default: // must be a binary operator - assert(CE->getOpcode() >= Instruction::FirstBinaryOp && - CE->getOpcode() < Instruction::NumBinaryOps && + assert(CE->getOpcode() >= Instruction::BinaryOpsBegin && + CE->getOpcode() < Instruction::BinaryOpsEnd && "Unrecognized opcode in ConstantExpr"); getArg1 = CE->getOperand(0); if (ConstantExpr* CEarg = dyn_cast(getArg1)) diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp index 5abfe272387..7c9d60fa204 100644 --- a/lib/Transforms/Instrumentation/TraceValues.cpp +++ b/lib/Transforms/Instrumentation/TraceValues.cpp @@ -179,7 +179,7 @@ static inline bool TraceThisOpCode(unsigned opCode) { // Explicitly test for opCodes *not* to trace so that any new opcodes will // be traced by default (VoidTy's are already excluded) // - return (opCode < Instruction::FirstOtherOp && + return (opCode < Instruction::OtherOpsBegin && opCode != Instruction::Alloca && opCode != Instruction::PHINode && opCode != Instruction::Cast); diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp index 667346c9c18..6ddcc08c828 100644 --- a/lib/VMCore/BasicBlock.cpp +++ b/lib/VMCore/BasicBlock.cpp @@ -19,7 +19,7 @@ // instruction list. This is not a real instruction. // struct DummyInst : public Instruction { - DummyInst() : Instruction(Type::VoidTy, NumOtherOps) { + DummyInst() : Instruction(Type::VoidTy, OtherOpsEnd) { // This should not be garbage monitored. LeakDetector::removeGarbageObject(this); } @@ -33,7 +33,7 @@ struct DummyInst : public Instruction { // Methods for support type inquiry through isa, cast, and dyn_cast... static inline bool classof(const DummyInst *) { return true; } static inline bool classof(const Instruction *I) { - return I->getOpcode() == NumOtherOps; + return I->getOpcode() == OtherOpsEnd; } static inline bool classof(const Value *V) { return isa(V) && classof(cast(V)); diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index d0413f12b34..8464c437fcb 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -634,8 +634,8 @@ ConstantExpr *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) { // Its not in the table so create a new one and put it in the table. // Check the operands for consistency first - assert((Opcode >= Instruction::FirstBinaryOp && - Opcode < Instruction::NumBinaryOps) && + assert((Opcode >= Instruction::BinaryOpsBegin && + Opcode < Instruction::BinaryOpsEnd) && "Invalid opcode in binary constant expression"); assert(C1->getType() == C2->getType() &&