rotate CallInst operands

with this commit the callee moves to the end of
the operand array (from the start) and the call
arguments now start at index 0 (formerly 1)

this ordering is now consistent with InvokeInst

this commit only flips the switch,
functionally it is equivalent to
r101465

I intend to commit several cleanups after a few
days of soak period



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@108240 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 12 insertions, 20 deletions

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 078bf6862f..af93a294cc 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -944,6 +944,9 @@ public:
   /// @deprecated these "define hacks" will go away soon
   /// @brief coerce out-of-tree code to abandon the low-level interfaces
   /// @detail see below comments and update your code to high-level interfaces
+  ///    - getOperand(0)  --->  getCalledValue(), or possibly getCalledFunction
+  ///    - setOperand(0, V)  --->  setCalledFunction(V)
+  ///
   ///    in LLVM v2.8-only code
   ///    - getOperand(N+1)  --->  getArgOperand(N)
   ///    - setOperand(N+1, V)  --->  setArgOperand(N, V)
@@ -961,23 +964,11 @@ public:
 # undef protected
 public:
 
-  enum { ArgOffset = 1 }; ///< temporary, do not use for new code!
+  enum { ArgOffset = 0 }; ///< temporary, do not use for new code!
   unsigned getNumArgOperands() const { return getNumOperands() - 1; }
   Value *getArgOperand(unsigned i) const { return getOperand(i + ArgOffset); }
   void setArgOperand(unsigned i, Value *v) { setOperand(i + ArgOffset, v); }
 
-  /// Provide compile-time errors for accessing operand 0
-  /// @deprecated these will go away soon
-  /// @detail see below comments and update your code to high-level interfaces
-  ///    - getOperand(0)  --->  getCalledValue(), or possibly getCalledFunction
-  ///    - setOperand(0, V)  --->  setCalledFunction(V)
-  ///
-private:
-  void getOperand(void*); // NO IMPL ---> use getCalledValue (or possibly
-                          //              getCalledFunction) instead
-  void setOperand(void*, Value*); // NO IMPL ---> use setCalledFunction instead
-public:
-
   /// getCallingConv/setCallingConv - Get or set the calling convention of this
   /// function call.
   CallingConv::ID getCallingConv() const {
diff --git a/lib/Target/CppBackend/CPPBackend.cpp b/lib/Target/CppBackend/CPPBackend.cpp
index 46a4ca4437..145568adcd 100644
--- a/lib/Target/CppBackend/CPPBackend.cpp
+++ b/lib/Target/CppBackend/CPPBackend.cpp
@@ -1400,18 +1400,18 @@ void CppWriter::printInstruction(const Instruction *I,
       Out << "std::vector<Value*> " << iName << "_params;";
       nl(Out);
       for (unsigned i = 0; i < call->getNumArgOperands(); ++i) {
-        Out << iName << "_params.push_back(" << opNames[i+1] << ");";
+        Out << iName << "_params.push_back(" << opNames[i] << ");";
         nl(Out);
       }
       Out << "CallInst* " << iName << " = CallInst::Create("
-          << opNames[0] << ", " << iName << "_params.begin(), "
+          << opNames[call->getNumArgOperands()] << ", " << iName << "_params.begin(), "
           << iName << "_params.end(), \"";
     } else if (call->getNumArgOperands() == 1) {
       Out << "CallInst* " << iName << " = CallInst::Create("
-          << opNames[0] << ", " << opNames[1] << ", \"";
+          << opNames[call->getNumArgOperands()] << ", " << opNames[0] << ", \"";
     } else {
-      Out << "CallInst* " << iName << " = CallInst::Create(" << opNames[0]
-          << ", \"";
+      Out << "CallInst* " << iName << " = CallInst::Create("
+          << opNames[call->getNumArgOperands()] << ", \"";
     }
     printEscapedString(call->getName());
     Out << "\", " << bbname << ");";
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 383f062a05..f97699dabd 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -1454,7 +1454,7 @@ void Verifier::visitInstruction(Instruction &I) {
     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
       // Check to make sure that the "address of" an intrinsic function is never
       // taken.
-      Assert1(!F->isIntrinsic() || (i == 0 && isa<CallInst>(I)),
+      Assert1(!F->isIntrinsic() || (i + 1 == e && isa<CallInst>(I)),
               "Cannot take the address of an intrinsic!", &I);
       Assert1(F->getParent() == Mod, "Referencing function in another module!",
               &I);
@@ -1537,7 +1537,8 @@ void Verifier::visitInstruction(Instruction &I) {
                 "Instruction does not dominate all uses!", Op, &I);
       }
     } else if (isa<InlineAsm>(I.getOperand(i))) {
-      Assert1((i == 0 && isa<CallInst>(I)) || (i + 3 == e && isa<InvokeInst>(I)),
+      Assert1((i + 1 == e && isa<CallInst>(I)) ||
+              (i + 3 == e && isa<InvokeInst>(I)),
               "Cannot take the address of an inline asm!", &I);
     }
   }