- 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

8 files changed, 29 insertions, 29 deletions

diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h
index fc1917b..09c08b8 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<Instruction>(V) && classof(cast<Instruction>(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<Instruction>(V) && classof(cast<Instruction>(V));
diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index 0674f0e..89c6409 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 4036099..a4750b0 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 148b76e..662c80a 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<int> MaxConstantsTable(Instruction::NumOtherOps);
+vector<int> 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 916938d..56c34ed 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<ConstantExpr>(getArg1))
diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp
index 5abfe27..7c9d60f 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 667346c..6ddcc08 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<Instruction>(V) && classof(cast<Instruction>(V));
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index d0413f1..8464c43 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() &&