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

fix PR7519: after thrashing around and remembering how all this stuff 

works, the fix is quite simple: just make sure to call ConvertTypeRecursive
when the function type being lowered is in the midst of ConvertType.

llvm-svn: 107173
This commit is contained in:
Chris Lattner 2010-06-29 17:56:33 +00:00
parent cdf87024ed
commit ab1e65e2ea
5 changed files with 67 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -61,28 +61,31 @@ static CanQualType GetReturnType(QualType RetTy) {
}
const CGFunctionInfo &
CodeGenTypes::getFunctionInfo(CanQual<FunctionNoProtoType> FTNP) {
CodeGenTypes::getFunctionInfo(CanQual<FunctionNoProtoType> FTNP,
bool IsRecursive) {
return getFunctionInfo(FTNP->getResultType().getUnqualifiedType(),
llvm::SmallVector<CanQualType, 16>(),
FTNP->getExtInfo());
FTNP->getExtInfo(), IsRecursive);
}
/// \param Args - contains any initial parameters besides those
/// in the formal type
static const CGFunctionInfo &getFunctionInfo(CodeGenTypes &CGT,
llvm::SmallVectorImpl<CanQualType> &ArgTys,
CanQual<FunctionProtoType> FTP) {
CanQual<FunctionProtoType> FTP,
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());
return CGT.getFunctionInfo(ResTy, ArgTys, FTP->getExtInfo(), IsRecursive);
}
const CGFunctionInfo &
CodeGenTypes::getFunctionInfo(CanQual<FunctionProtoType> FTP) {
CodeGenTypes::getFunctionInfo(CanQual<FunctionProtoType> FTP,
bool IsRecursive) {
llvm::SmallVector<CanQualType, 16> ArgTys;
return ::getFunctionInfo(*this, ArgTys, FTP);
return ::getFunctionInfo(*this, ArgTys, FTP, IsRecursive);
}
static CallingConv getCallingConventionForDecl(const Decl *D) {
@ -215,7 +218,8 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(QualType ResTy,
const CGFunctionInfo &CodeGenTypes::getFunctionInfo(CanQualType ResTy,
const llvm::SmallVectorImpl<CanQualType> &ArgTys,
const FunctionType::ExtInfo &Info) {
const FunctionType::ExtInfo &Info,
bool IsRecursive) {
#ifndef NDEBUG
for (llvm::SmallVectorImpl<CanQualType>::const_iterator
I = ArgTys.begin(), E = ArgTys.end(); I != E; ++I)
@ -243,8 +247,17 @@ const CGFunctionInfo &CodeGenTypes::getFunctionInfo(CanQualType ResTy,
// various situations, pass it in.
llvm::SmallVector<const llvm::Type *, 8> PreferredArgTypes;
for (llvm::SmallVectorImpl<CanQualType>::const_iterator
I = ArgTys.begin(), E = ArgTys.end(); I != E; ++I)
PreferredArgTypes.push_back(ConvertType(*I));
I = ArgTys.begin(), E = ArgTys.end(); I != E; ++I) {
// If this is being called from the guts of the ConvertType loop, make sure
// to call ConvertTypeRecursive so we don't get into issues with cyclic
// pointer type structures.
const llvm::Type *ArgType;
if (IsRecursive)
ArgType = ConvertTypeRecursive(*I);
else
ArgType = ConvertType(*I);
PreferredArgTypes.push_back(ArgType);
}
// Compute ABI information.
getABIInfo().computeInfo(*FI, getContext(), TheModule.getContext(),

35
clang/lib/CodeGen/CodeGenTypes.cpp
View File

@ -46,7 +46,7 @@ CodeGenTypes::~CodeGenTypes() {
const llvm::Type *CodeGenTypes::ConvertType(QualType T) {
llvm::PATypeHolder Result = ConvertTypeRecursive(T);
// Any pointers that were converted defered evaluation of their pointee type,
// Any pointers that were converted deferred evaluation of their pointee type,
// creating an opaque type instead. This is in order to avoid problems with
// circular types. Loop through all these defered pointees, if any, and
// resolve them now.
@ -284,7 +284,8 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
assert(A.getIndexTypeCVRQualifiers() == 0 &&
"FIXME: We only handle trivial array types so far!");
// int X[] -> [0 x int]
return llvm::ArrayType::get(ConvertTypeForMemRecursive(A.getElementType()), 0);
return llvm::ArrayType::get(ConvertTypeForMemRecursive(A.getElementType()),
0);
}
case Type::ConstantArray: {
const ConstantArrayType &A = cast<ConstantArrayType>(Ty);
@ -299,7 +300,11 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
}
case Type::FunctionNoProto:
case Type::FunctionProto: {
// First, check whether we can build the full function type.
// First, check whether we can build the full function type. If the
// function type depends on an incomplete type (e.g. a struct or enum), we
// cannot lower the function type. Instead, turn it into an Opaque pointer
// and have UpdateCompletedType revisit the function type when/if the opaque
// argument type is defined.
if (const TagType *TT = VerifyFuncTypeComplete(&Ty)) {
// This function's type depends on an incomplete tag type; make sure
// we have an opaque type corresponding to the tag type.
@ -309,17 +314,25 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
FunctionTypes.insert(std::make_pair(&Ty, ResultType));
return ResultType;
}
// The function type can be built; call the appropriate routines to
// build it.
if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(&Ty))
return GetFunctionType(getFunctionInfo(
CanQual<FunctionProtoType>::CreateUnsafe(QualType(FPT,0))),
FPT->isVariadic());
const CGFunctionInfo *FI;
bool isVariadic;
if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(&Ty)) {
FI = &getFunctionInfo(
CanQual<FunctionProtoType>::CreateUnsafe(QualType(FPT, 0)),
true /*Recursive*/);
isVariadic = FPT->isVariadic();
} else {
const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(&Ty);
FI = &getFunctionInfo(
CanQual<FunctionNoProtoType>::CreateUnsafe(QualType(FNPT, 0)),
true /*Recursive*/);
isVariadic = true;
}
const FunctionNoProtoType *FNPT = cast<FunctionNoProtoType>(&Ty);
return GetFunctionType(getFunctionInfo(
CanQual<FunctionNoProtoType>::CreateUnsafe(QualType(FNPT,0))),
true);
return GetFunctionType(*FI, isVariadic);
}
case Type::ObjCObject:

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

@ -154,8 +154,11 @@ public:
return getFunctionInfo(Ty->getResultType(), Args,
Ty->getExtInfo());
}
const CGFunctionInfo &getFunctionInfo(CanQual<FunctionProtoType> Ty);
const CGFunctionInfo &getFunctionInfo(CanQual<FunctionNoProtoType> Ty);
const CGFunctionInfo &getFunctionInfo(CanQual<FunctionProtoType> Ty,
bool IsRecursive = false);
const CGFunctionInfo &getFunctionInfo(CanQual<FunctionNoProtoType> Ty,
bool IsRecursive = false);
// getFunctionInfo - Get the function info for a member function.
const CGFunctionInfo &getFunctionInfo(const CXXRecordDecl *RD,
@ -176,7 +179,8 @@ public:
/// \param ArgTys - must all actually be canonical as params
const CGFunctionInfo &getFunctionInfo(CanQualType RetTy,
const llvm::SmallVectorImpl<CanQualType> &ArgTys,
const FunctionType::ExtInfo &Info);
const FunctionType::ExtInfo &Info,
bool IsRecursive = false);
/// \brief Compute a new LLVM record layout object for the given record.
CGRecordLayout *ComputeRecordLayout(const RecordDecl *D);

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

@ -830,8 +830,7 @@ X86_64ABIInfo::Class X86_64ABIInfo::merge(Class Accum, Class Field) {
return SSE;
}
void X86_64ABIInfo::classify(QualType Ty,
uint64_t OffsetBase,
void X86_64ABIInfo::classify(QualType Ty, uint64_t OffsetBase,
Class &Lo, Class &Hi) const {
// FIXME: This code can be simplified by introducing a simple value class for
// Class pairs with appropriate constructor methods for the various

13
clang/test/CodeGen/decl.c
View File

@ -89,3 +89,16 @@ struct test7s { int a; int b; } test7[] = {
struct test8s { int f0; char f1; } test8g = {};
// PR7519
struct S {
void (*x) (struct S *);
};
extern struct S *global_dc;
void cp_diagnostic_starter(struct S *);
void init_error(void) {
global_dc->x = cp_diagnostic_starter;
}