Revert "Add CC_Win64ThisCall and set it in the necessary places."

This reverts commit 126863.

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

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 2b34b716d419cf037b1af085c68c42b36e788697..9b177cceed965d9c9387ff1385b67dacf22ba535 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -354,8 +354,7 @@ enum CallingConv {
   CC_X86StdCall,  // __attribute__((stdcall))
   CC_X86FastCall, // __attribute__((fastcall))
   CC_X86ThisCall, // __attribute__((thiscall))
-  CC_X86Pascal,   // __attribute__((pascal))
-  CC_Win64ThisCall
+  CC_X86Pascal    // __attribute__((pascal))
 };
 
 typedef std::pair<const Type*, Qualifiers> SplitQualType;

diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h
index 446fec59ac23a8472cb2ae754cdf22f46bc4afa3..b9087f2c47e8eba159f196abd98c82bf23588c15 100644 (file)
--- a/include/clang/Basic/TargetInfo.h
+++ b/include/clang/Basic/TargetInfo.h
@@ -530,12 +530,6 @@ public:
   virtual const char *getStaticInitSectionSpecifier() const {
     return 0;
   }
-
-  // isWin64 - Whether the target is MSVC Win64.
-  bool isWin64() const {
-    return     (Triple.getArch() == llvm::Triple::x86_64)
-            && (Triple.getOS()   == llvm::Triple::Win32);
-  }
 protected:
   virtual uint64_t getPointerWidthV(unsigned AddrSpace) const {
     return PointerWidth;

diff --git a/lib/AST/DumpXML.cpp b/lib/AST/DumpXML.cpp
index 4f548b265c40fbe649619f55bd4c97c8bea71b1a..9d828fcfb85a3d8619cee9e74dc08ecc49a31f2d 100644 (file)
--- a/lib/AST/DumpXML.cpp
+++ b/lib/AST/DumpXML.cpp
@@ -911,7 +911,6 @@ struct XMLDumper : public XMLDeclVisitor<XMLDumper>,
     case CC_X86StdCall: return set("cc", "x86_stdcall");
     case CC_X86ThisCall: return set("cc", "x86_thiscall");
     case CC_X86Pascal: return set("cc", "x86_pascal");
-    case CC_Win64ThisCall: return set("cc", "win64_thiscall");
     }
   }
 

diff --git a/lib/AST/MicrosoftMangle.cpp b/lib/AST/MicrosoftMangle.cpp
index f5bdd4b537bebf606dfebdc7b7a6f1c6ad4bfb9b..4bf7f23a0a9d709e9776593023ba1be19b66b9c5 100644 (file)
--- a/lib/AST/MicrosoftMangle.cpp
+++ b/lib/AST/MicrosoftMangle.cpp
@@ -879,9 +879,6 @@ void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T,
     case CC_X86ThisCall: Out << 'E'; break;
     case CC_X86StdCall: Out << 'G'; break;
     case CC_X86FastCall: Out << 'I'; break;
-    case CC_Win64ThisCall:
-      assert(false && "Don't know how to mangle Win64 thiscall cc yet!");
-      break;
   }
 }
 void MicrosoftCXXNameMangler::mangleThrowSpecification(

diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 2cab2214487c28ef3b96acd9972cc3d683a45441..cde865f5b9f18e4e3b5d16df0cca2dd049ada950 100644 (file)
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -1157,7 +1157,6 @@ llvm::StringRef FunctionType::getNameForCallConv(CallingConv CC) {
   case CC_X86FastCall: return "fastcall";
   case CC_X86ThisCall: return "thiscall";
   case CC_X86Pascal: return "pascal";
-  case CC_Win64ThisCall: return "win64_thiscall";
   }
 
   llvm_unreachable("Invalid calling convention.");

diff --git a/lib/CodeGen/CGBlocks.cpp b/lib/CodeGen/CGBlocks.cpp
index 8cd1f5e38d375ae332c954697a090e32c592aa31..9587de223aa759e33d1484f1131e7fa2b1a2b05b 100644 (file)
--- a/lib/CodeGen/CGBlocks.cpp
+++ b/lib/CodeGen/CGBlocks.cpp
@@ -922,7 +922,7 @@ CodeGenFunction::GenerateBlockFunction(GlobalDecl GD,
 
   // Begin generating the function.
   StartFunction(blockDecl, fnType->getResultType(), fn, args,
-                blockInfo.getBlockExpr()->getBody()->getLocEnd(), CC_Default);
+                blockInfo.getBlockExpr()->getBody()->getLocEnd());
   CurFuncDecl = outerFnDecl; // StartFunction sets this to blockDecl
 
   // Okay.  Undo some of what StartFunction did.
@@ -1078,7 +1078,7 @@ CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
                                           SC_None,
                                           false,
                                           true);
-  StartFunction(FD, C.VoidTy, Fn, args, SourceLocation(), CC_Default);
+  StartFunction(FD, C.VoidTy, Fn, args, SourceLocation());
 
   const llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
 
@@ -1167,7 +1167,7 @@ CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) {
                                           SC_Static,
                                           SC_None,
                                           false, true);
-  StartFunction(FD, C.VoidTy, Fn, args, SourceLocation(), CC_Default);
+  StartFunction(FD, C.VoidTy, Fn, args, SourceLocation());
 
   const llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
 
@@ -1270,7 +1270,7 @@ GeneratebyrefCopyHelperFunction(const llvm::Type *T, BlockFieldFlags flags,
                                           SC_Static,
                                           SC_None,
                                           false, true);
-  StartFunction(FD, R, Fn, Args, SourceLocation(), CC_Default);
+  StartFunction(FD, R, Fn, Args, SourceLocation());
 
   // dst->x
   llvm::Value *V = GetAddrOfLocalVar(Dst);
@@ -1340,7 +1340,7 @@ CodeGenFunction::GeneratebyrefDestroyHelperFunction(const llvm::Type *T,
                                           SC_Static,
                                           SC_None,
                                           false, true);
-  StartFunction(FD, R, Fn, Args, SourceLocation(), CC_Default);
+  StartFunction(FD, R, Fn, Args, SourceLocation());
 
   llvm::Value *V = GetAddrOfLocalVar(Src);
   V = Builder.CreateBitCast(V, llvm::PointerType::get(T, 0));

diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp
index 3c3765a1ae5954ae62331f5d8ba06cb8846b176c..1d9a9a6a8ceb00d711b275baf5c8c4276eab589e 100644 (file)
--- a/lib/CodeGen/CGCall.cpp
+++ b/lib/CodeGen/CGCall.cpp
@@ -36,7 +36,6 @@ static unsigned ClangCallConvToLLVMCallConv(CallingConv CC) {
   case CC_X86StdCall: return llvm::CallingConv::X86_StdCall;
   case CC_X86FastCall: return llvm::CallingConv::X86_FastCall;
   case CC_X86ThisCall: return llvm::CallingConv::X86_ThisCall;
-  case CC_Win64ThisCall: return llvm::CallingConv::Win64_ThisCall;
   // TODO: add support for CC_X86Pascal to llvm
   }
 }
@@ -76,23 +75,19 @@ CodeGenTypes::getFunctionInfo(CanQual<FunctionNoProtoType> FTNP,
 static const CGFunctionInfo &getFunctionInfo(CodeGenTypes &CGT,
                                   llvm::SmallVectorImpl<CanQualType> &ArgTys,
                                              CanQual<FunctionProtoType> FTP,
-                                             CallingConv CC,
                                              bool IsRecursive = false) {
   // FIXME: Kill copy.
   for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
     ArgTys.push_back(FTP->getArgType(i));
   CanQualType ResTy = FTP->getResultType().getUnqualifiedType();
-
-  return CGT.getFunctionInfo(ResTy, ArgTys,
-                             FTP->getExtInfo().withCallingConv(CC),
-                             IsRecursive);
+  return CGT.getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo(), IsRecursive);
 }
 
 const CGFunctionInfo &
 CodeGenTypes::getFunctionInfo(CanQual<FunctionProtoType> FTP,
                               bool IsRecursive) {
   llvm::SmallVector<CanQualType, 16> ArgTys;
-  return ::getFunctionInfo(*this, ArgTys, FTP, CC_Default, IsRecursive);
+  return ::getFunctionInfo(*this, ArgTys, FTP, IsRecursive);
 }
 
 static CallingConv getCallingConventionForDecl(const Decl *D) {
@@ -119,10 +114,8 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXRecordDecl *RD,
   // Add the 'this' pointer.
   ArgTys.push_back(GetThisType(Context, RD));
 
-  CallingConv CC = Context.Target.isWin64() ? CC_Win64ThisCall : CC_Default;
-
   return ::getFunctionInfo(*this, ArgTys,
-           FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>(), CC);
+              FTP->getCanonicalTypeUnqualified().getAs<FunctionProtoType>());
 }
 
 const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXMethodDecl *MD) {
@@ -135,9 +128,7 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXMethodDecl *MD) {
   if (MD->isInstance())
     ArgTys.push_back(GetThisType(Context, MD->getParent()));
 
-  CallingConv CC = Context.Target.isWin64() ? CC_Win64ThisCall : CC_Default;
-
-  return ::getFunctionInfo(*this, ArgTys, GetFormalType(MD), CC);
+  return ::getFunctionInfo(*this, ArgTys, GetFormalType(MD));
 }
 
 const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXConstructorDecl *D,
@@ -154,9 +145,7 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXConstructorDecl *D,
   for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
     ArgTys.push_back(FTP->getArgType(i));
 
-  CallingConv CC = Context.Target.isWin64() ? CC_Win64ThisCall : CC_Default;
-
-  return getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo().withCallingConv(CC));
+  return getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo());
 }
 
 const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXDestructorDecl *D,
@@ -170,9 +159,7 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const CXXDestructorDecl *D,
   CanQual<FunctionProtoType> FTP = GetFormalType(D);
   assert(FTP->getNumArgs() == 0 && "dtor with formal parameters");
 
-  CallingConv CC = Context.Target.isWin64() ? CC_Win64ThisCall : CC_Default;
-
-  return getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo().withCallingConv(CC));
+  return getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo());
 }
 
 const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionDecl *FD) {
@@ -263,8 +250,8 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(CanQualType ResTy,
     return *FI;
 
   // Construct the function info.
-  FI = new CGFunctionInfo(CC, Info.getNoReturn(), Info.getRegParm(),
-                          ResTy, ArgTys.data(), ArgTys.size());
+  FI = new CGFunctionInfo(CC, Info.getNoReturn(), Info.getRegParm(), ResTy,
+                          ArgTys.data(), ArgTys.size());
   FunctionInfos.InsertNode(FI, InsertPos);
 
   // Compute ABI information.

diff --git a/lib/CodeGen/CGDeclCXX.cpp b/lib/CodeGen/CGDeclCXX.cpp
index e9c6d003de11f7cbb29f8bae0c9ab17d1eb110ed..8b37e9af3c6d830d5f1c60359b2d45e3ea4c992c 100644 (file)
--- a/lib/CodeGen/CGDeclCXX.cpp
+++ b/lib/CodeGen/CGDeclCXX.cpp
@@ -261,7 +261,7 @@ void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
                                                        const VarDecl *D,
                                                  llvm::GlobalVariable *Addr) {
   StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(),
-                SourceLocation(), CC_Default);
+                SourceLocation());
 
   // Use guarded initialization if the global variable is weak due to
   // being a class template's static data member.
@@ -278,7 +278,7 @@ void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
                                                 llvm::Constant **Decls,
                                                 unsigned NumDecls) {
   StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(),
-                SourceLocation(), CC_Default);
+                SourceLocation());
 
   for (unsigned i = 0; i != NumDecls; ++i)
     if (Decls[i])
@@ -290,10 +290,8 @@ void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
 void CodeGenFunction::GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
                   const std::vector<std::pair<llvm::WeakVH, llvm::Constant*> >
                                                 &DtorsAndObjects) {
-  const bool IsWin64 = getContext().Target.isWin64();
-
   StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(),
-                SourceLocation(), IsWin64 ? CC_Win64ThisCall : CC_Default);
+                SourceLocation());
 
   // Emit the dtors, in reverse order from construction.
   for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {
@@ -329,8 +327,7 @@ CodeGenFunction::GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
   llvm::Function *Fn = 
     CreateGlobalInitOrDestructFunction(CGM, FTy, "__cxx_global_array_dtor");
 
-  StartFunction(GlobalDecl(), getContext().VoidTy, Fn, Args, SourceLocation(),
-                CC_Default);
+  StartFunction(GlobalDecl(), getContext().VoidTy, Fn, Args, SourceLocation());
 
   QualType BaseElementTy = getContext().getBaseElementType(Array);
   const llvm::Type *BasePtr = ConvertType(BaseElementTy)->getPointerTo();

diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index f2cd951d27adc11db2a294288b87311427e39334..0f9abc7c351807634ec9c04a2222721ce8b2d68a 100644 (file)
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -2121,7 +2121,7 @@ RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
   CallArgList Args;
   EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
 
-  return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType, CC_Default),
+  return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType),
                   Callee, ReturnValue, Args, TargetDecl);
 }
 

diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp
index 06d04a5e52825d58d05910119b201cc0f9dc1846..bba7864bff988e77952da5f1e64739811c432fc3 100644 (file)
--- a/lib/CodeGen/CGExprCXX.cpp
+++ b/lib/CodeGen/CGExprCXX.cpp
@@ -48,13 +48,8 @@ RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
   EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
 
   QualType ResultType = FPT->getResultType();
-  FunctionType::ExtInfo Info = FPT->getExtInfo();
-
-  if (getContext().Target.isWin64()) {
-      Info = Info.withCallingConv(CC_Win64ThisCall);
-  }
-
-  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args, Info),
+  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
+                                                 FPT->getExtInfo()),
                   Callee, ReturnValue, Args, MD);
 }
 
@@ -297,11 +292,8 @@ CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
   // And the rest of the call args
   EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end());
   const FunctionType *BO_FPT = BO->getType()->getAs<FunctionProtoType>();
-
-  const CGFunctionInfo &FI = CGM.getTypes().getFunctionInfo(Args, BO_FPT,
-          CGM.getContext().Target.isWin64() ? CC_Win64ThisCall : CC_Default);
-
-  return EmitCall(FI , Callee, ReturnValue, Args);
+  return EmitCall(CGM.getTypes().getFunctionInfo(Args, BO_FPT), Callee, 
+                  ReturnValue, Args);
 }
 
 RValue
@@ -818,10 +810,8 @@ namespace {
       for (unsigned I = 0; I != NumPlacementArgs; ++I)
         DeleteArgs.push_back(std::make_pair(getPlacementArgs()[I], *AI++));
 
-      // FIXME Check whether this needs thiscall on Win64.
       // Call 'operator delete'.
-      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT,
-                                                      CC_Default),
+      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT),
                    CGF.CGM.GetAddrOfFunction(OperatorDelete),
                    ReturnValueSlot(), DeleteArgs, OperatorDelete);
     }
@@ -881,10 +871,8 @@ namespace {
         DeleteArgs.push_back(std::make_pair(RV, *AI++));
       }
 
-      // FIXME Check whether this needs thiscall on Win64.
       // Call 'operator delete'.
-      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT,
-                                                      CC_Default),
+      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT),
                    CGF.CGM.GetAddrOfFunction(OperatorDelete),
                    ReturnValueSlot(), DeleteArgs, OperatorDelete);
     }
@@ -988,7 +976,7 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
 
   // Emit the call to new.
   RValue RV =
-    EmitCall(CGM.getTypes().getFunctionInfo(NewArgs, NewFTy, CC_Default),
+    EmitCall(CGM.getTypes().getFunctionInfo(NewArgs, NewFTy),
              CGM.GetAddrOfFunction(NewFD), ReturnValueSlot(), NewArgs, NewFD);
 
   // If an allocation function is declared with an empty exception specification
@@ -1098,7 +1086,7 @@ void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
     DeleteArgs.push_back(std::make_pair(RValue::get(Size), SizeTy));
 
   // Emit the call to delete.
-  EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy, CC_Default),
+  EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy),
            CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(), 
            DeleteArgs, DeleteFD);
 }
@@ -1219,7 +1207,7 @@ namespace {
       }
 
       // Emit the call to delete.
-      CGF.EmitCall(CGF.getTypes().getFunctionInfo(Args, DeleteFTy, CC_Default),
+      CGF.EmitCall(CGF.getTypes().getFunctionInfo(Args, DeleteFTy),
                    CGF.CGM.GetAddrOfFunction(OperatorDelete),
                    ReturnValueSlot(), Args, OperatorDelete);
     }

diff --git a/lib/CodeGen/CGObjC.cpp b/lib/CodeGen/CGObjC.cpp
index 6ae1ac8a49c977b99737f519f45aeb433c7fa52c..5d34907699916734f14faaae436c87fd13775ae1 100644 (file)
--- a/lib/CodeGen/CGObjC.cpp
+++ b/lib/CodeGen/CGObjC.cpp
@@ -140,8 +140,7 @@ void CodeGenFunction::StartObjCMethod(const ObjCMethodDecl *OMD,
 
   CurGD = OMD;
 
-  StartFunction(OMD, OMD->getResultType(), Fn, Args, OMD->getLocStart(),
-                CC_Default);
+  StartFunction(OMD, OMD->getResultType(), Fn, Args, OMD->getLocStart());
 }
 
 void CodeGenFunction::GenerateObjCGetterBody(ObjCIvarDecl *Ivar, 

diff --git a/lib/CodeGen/CGVTables.cpp b/lib/CodeGen/CGVTables.cpp
index 6acbe436c85db7ca43ed1312430a95596f92dee0..891697f4cd09edf84ae8851f2d042c6689bc6e72 100644 (file)
--- a/lib/CodeGen/CGVTables.cpp
+++ b/lib/CodeGen/CGVTables.cpp
@@ -2582,11 +2582,8 @@ void CodeGenFunction::GenerateThunk(llvm::Function *Fn, GlobalDecl GD,
     
     FunctionArgs.push_back(std::make_pair(Param, Param->getType()));
   }
-
-  const bool IsWin64 = CGM.getContext().Target.isWin64();
-
-  StartFunction(GlobalDecl(), ResultType, Fn, FunctionArgs, SourceLocation(),
-                IsWin64 ? CC_Win64ThisCall : CC_Default);
+  
+  StartFunction(GlobalDecl(), ResultType, Fn, FunctionArgs, SourceLocation());
 
   CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
 
@@ -2617,14 +2614,9 @@ void CodeGenFunction::GenerateThunk(llvm::Function *Fn, GlobalDecl GD,
                                    FPT->isVariadic());
   llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
 
-  FunctionType::ExtInfo Info = FPT->getExtInfo();
-
-  if (IsWin64) {
-      Info = Info.withCallingConv(CC_Win64ThisCall);
-  }
-
   const CGFunctionInfo &FnInfo = 
-    CGM.getTypes().getFunctionInfo(ResultType, CallArgs, Info);
+    CGM.getTypes().getFunctionInfo(ResultType, CallArgs,
+                                   FPT->getExtInfo());
   
   // Determine whether we have a return value slot to use.
   ReturnValueSlot Slot;

diff --git a/lib/CodeGen/CodeGenFunction.cpp b/lib/CodeGen/CodeGenFunction.cpp
index 9660b071e2c735345baec60c0665937bf4580ad3..4ab327712a59ae46c782de2ca7cd09ead832fa3b 100644 (file)
--- a/lib/CodeGen/CodeGenFunction.cpp
+++ b/lib/CodeGen/CodeGenFunction.cpp
@@ -211,8 +211,7 @@ void CodeGenFunction::EmitMCountInstrumentation() {
 void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
                                     llvm::Function *Fn,
                                     const FunctionArgList &Args,
-                                    SourceLocation StartLoc,
-                                    CallingConv CC) {
+                                    SourceLocation StartLoc) {
   const Decl *D = GD.getDecl();
   
   DidCallStackSave = false;
@@ -279,7 +278,7 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
   // FIXME: Leaked.
   // CC info is ignored, hopefully?
   CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args,
-                                              FunctionType::ExtInfo().withCallingConv(CC));
+                                              FunctionType::ExtInfo());
 
   if (RetTy->isVoidType()) {
     // Void type; nothing to return.
@@ -360,7 +359,7 @@ void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) {
   if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
 
   // Emit the standard function prologue.
-  StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin(), CC_Default);
+  StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin());
 
   // Generate the body of the function.
   if (isa<CXXDestructorDecl>(FD))

diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index 9b698d3306052df90b05ae95b90ab6d2c8c5ec5f..0edd0f01281c22df5b0698fd2796e6e8227f2cf0 100644 (file)
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -1126,8 +1126,7 @@ public:
   void StartFunction(GlobalDecl GD, QualType RetTy,
                      llvm::Function *Fn,
                      const FunctionArgList &Args,
-                     SourceLocation StartLoc,
-                     CallingConv CC);
+                     SourceLocation StartLoc);
 
   void EmitConstructorBody(FunctionArgList &Args);
   void EmitDestructorBody(FunctionArgList &Args);

diff --git a/lib/CodeGen/CodeGenTypes.h b/lib/CodeGen/CodeGenTypes.h
index 6bf3f92adaf797890581bd5787a2ab92d177b0ad..41513daf17caac090d85e0ee347fac8c2bdcf5e6 100644 (file)
--- a/lib/CodeGen/CodeGenTypes.h
+++ b/lib/CodeGen/CodeGenTypes.h
@@ -161,11 +161,9 @@ public:
                                         CXXDtorType Type);
 
   const CGFunctionInfo &getFunctionInfo(const CallArgList &Args,
-                                        const FunctionType *Ty,
-                                        CallingConv CC) {
-    FunctionType::ExtInfo Info = Ty->getExtInfo().withCallingConv(CC);
-
-    return getFunctionInfo(Ty->getResultType(), Args, Info);
+                                        const FunctionType *Ty) {
+    return getFunctionInfo(Ty->getResultType(), Args,
+                           Ty->getExtInfo());
   }
 
   const CGFunctionInfo &getFunctionInfo(CanQual<FunctionProtoType> Ty,

diff --git a/lib/CodeGen/TargetInfo.cpp b/lib/CodeGen/TargetInfo.cpp
index 14a6e0a58948c9b5fba35d86dba38d158fd6bd3e..2ffc840b9f9214688a137c32fdb7162eee9b5861 100644 (file)
--- a/lib/CodeGen/TargetInfo.cpp
+++ b/lib/CodeGen/TargetInfo.cpp
@@ -942,26 +942,6 @@ public:
 
     return false;
   }
-
-  void SetTargetAttributes(const Decl *D,
-                           llvm::GlobalValue *GV,
-                           CodeGen::CodeGenModule &M) const {
-    if (M.getContext().Target.isWin64()) {
-      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
-        const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(FD);
-
-        if ((M && M->isInstance())
-            || dyn_cast<CXXConstructorDecl>(FD)
-            || dyn_cast<CXXDestructorDecl>(FD)) {
-              // When using the MSVC Win64 ABI, methods/constructors/destructors
-              // use the Win64 thiscall calling convention.
-              llvm::Function *F = cast<llvm::Function>(GV);
-              F->setCallingConv(llvm::CallingConv::Win64_ThisCall);
-        }
-      }
-    }
-  }
-
 };
 
 }