maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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

This reverts commit 126863.

llvm-svn: 126886
This commit is contained in:
Tilmann Scheller 2011-03-02 21:36:49 +00:00
parent 5f2a4f999d
commit 99cc30c371
16 changed files with 40 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
clang/include/clang/AST/Type.h
View File

@ -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;

6
clang/include/clang/Basic/TargetInfo.h
View File

@ -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;

1
clang/lib/AST/DumpXML.cpp
View File

@ -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");
}
}

3
clang/lib/AST/MicrosoftMangle.cpp
View File

@ -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(

1
clang/lib/AST/Type.cpp
View File

@ -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.");

10
clang/lib/CodeGen/CGBlocks.cpp
View File

@ -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));

29
clang/lib/CodeGen/CGCall.cpp
View File

@ -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.

11
clang/lib/CodeGen/CGDeclCXX.cpp
View File

@ -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();

2
clang/lib/CodeGen/CGExpr.cpp
View File

@ -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);
}

30
clang/lib/CodeGen/CGExprCXX.cpp
View File

@ -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);
}

3
clang/lib/CodeGen/CGObjC.cpp
View File

@ -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,

16
clang/lib/CodeGen/CGVTables.cpp
View File

@ -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;

7
clang/lib/CodeGen/CodeGenFunction.cpp
View File

@ -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))

3
clang/lib/CodeGen/CodeGenFunction.h
View File

@ -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);

8
clang/lib/CodeGen/CodeGenTypes.h
View File

@ -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,

20
clang/lib/CodeGen/TargetInfo.cpp
View File

@ -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);
}
}
}
}
};
}