add support for explicit calling conventions

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

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 6db1a9a26c1947ead79a87f1cd6b80f8e1c9ef8b..889ae4067cbc74f591b34170747de652252c05f0 100644 (file)
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -18,6 +18,7 @@
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Assembly/PrintModulePass.h"
 #include "llvm/Assembly/AsmAnnotationWriter.h"
+#include "llvm/CallingConv.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Instruction.h"
@@ -915,6 +916,14 @@ void AssemblyWriter::printFunction(const Function *F) {
       abort();
     }
 
+  // Print the calling convention.
+  switch (F->getCallingConv()) {
+  case CallingConv::C: break;   // default
+  case CallingConv::Fast: Out << "fastcc "; break;
+  case CallingConv::Cold: Out << "coldcc "; break;
+  default: Out << "cc" << F->getCallingConv() << " "; break;
+  }
+
   printType(F->getReturnType()) << ' ';
   if (!F->getName().empty())
     Out << getLLVMName(F->getName());
@@ -1090,7 +1099,15 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     }
   } else if (isa<ReturnInst>(I) && !Operand) {
     Out << " void";
-  } else if (isa<CallInst>(I)) {
+  } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
+    // Print the calling convention being used.
+    switch (CI->getCallingConv()) {
+    case CallingConv::C: break;   // default
+    case CallingConv::Fast: Out << " fastcc"; break;
+    case CallingConv::Cold: Out << " coldcc"; break;
+    default: Out << " cc" << CI->getCallingConv(); break;
+    }
+
     const PointerType  *PTy = cast<PointerType>(Operand->getType());
     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     const Type       *RetTy = FTy->getReturnType();
@@ -1108,7 +1125,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
       writeOperand(Operand, true);
     }
     Out << '(';
-    if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true);
+    if (CI->getNumOperands() > 1) writeOperand(CI->getOperand(1), true);
     for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) {
       Out << ',';
       writeOperand(I.getOperand(op), true);
@@ -1120,6 +1137,14 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     const Type       *RetTy = FTy->getReturnType();
 
+    // Print the calling convention being used.
+    switch (II->getCallingConv()) {
+    case CallingConv::C: break;   // default
+    case CallingConv::Fast: Out << " fastcc"; break;
+    case CallingConv::Cold: Out << " coldcc"; break;
+    default: Out << " cc" << II->getCallingConv(); break;
+    }
+
     // If possible, print out the short form of the invoke instruction. We can
     // only do this if the first argument is a pointer to a nonvararg function,
     // and if the return type is not a pointer to a function.

diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index f61a4d2326241ce00029c813b7fbb262707a49f6..1e68289f652d657b8eeffd8cb9706c2766e42cdf 100644 (file)
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -77,6 +77,7 @@ void Argument::setParent(Function *parent) {
 Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
                    const std::string &name, Module *ParentModule)
   : GlobalValue(PointerType::get(Ty), Value::FunctionVal, 0, 0, Linkage, name) {
+  CallingConvention = 0;
   BasicBlocks.setItemParent(this);
   BasicBlocks.setParent(this);
   ArgumentList.setItemParent(this);

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index d5adaa79d952f1ffc1a76fb57be409272127c37c..7d3b0eecb88717fce73427b466996f3cb29735b0 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -20,6 +20,20 @@
 #include "llvm/Support/CallSite.h"
 using namespace llvm;
 
+unsigned CallSite::getCallingConv() const {
+  if (CallInst *CI = dyn_cast<CallInst>(I))
+    return CI->getCallingConv();
+  else
+    return cast<InvokeInst>(I)->getCallingConv();
+}
+void CallSite::setCallingConv(unsigned CC) {
+  if (CallInst *CI = dyn_cast<CallInst>(I))
+    CI->setCallingConv(CC);
+  else
+    cast<InvokeInst>(I)->setCallingConv(CC);
+}
+
+
 //===----------------------------------------------------------------------===//
 //                            TerminatorInst Class
 //===----------------------------------------------------------------------===//
@@ -249,7 +263,7 @@ CallInst::CallInst(Value *Func, const std::string &Name,
 CallInst::CallInst(const CallInst &CI)
   : Instruction(CI.getType(), Instruction::Call, new Use[CI.getNumOperands()],
                 CI.getNumOperands()) {
-  setTailCall(CI.isTailCall());
+  SubclassData = CI.SubclassData;
   Use *OL = OperandList;
   Use *InOL = CI.OperandList;
   for (unsigned i = 0, e = CI.getNumOperands(); i != e; ++i)
@@ -306,6 +320,7 @@ InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
 InvokeInst::InvokeInst(const InvokeInst &II)
   : TerminatorInst(II.getType(), Instruction::Invoke,
                    new Use[II.getNumOperands()], II.getNumOperands()) {
+  SubclassData = II.SubclassData;
   Use *OL = OperandList, *InOL = II.OperandList;
   for (unsigned i = 0, e = II.getNumOperands(); i != e; ++i)
     OL[i].init(InOL[i], this);