2006-11-10 14:34:16 +08:00
|
|
|
//===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 03:59:25 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2006-11-10 14:34:16 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the ASTContext interface.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/AST/ASTContext.h"
|
2009-12-22 22:23:30 +08:00
|
|
|
#include "clang/AST/CharUnits.h"
|
2008-08-08 04:55:28 +08:00
|
|
|
#include "clang/AST/DeclCXX.h"
|
2007-10-02 03:00:59 +08:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2009-02-05 03:02:06 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
2009-08-19 09:27:32 +08:00
|
|
|
#include "clang/AST/TypeLoc.h"
|
2008-08-11 12:54:23 +08:00
|
|
|
#include "clang/AST/Expr.h"
|
2010-05-20 09:18:31 +08:00
|
|
|
#include "clang/AST/ExprCXX.h"
|
2009-04-10 06:27:44 +08:00
|
|
|
#include "clang/AST/ExternalASTSource.h"
|
2010-10-25 01:26:36 +08:00
|
|
|
#include "clang/AST/ASTMutationListener.h"
|
2009-07-19 03:43:29 +08:00
|
|
|
#include "clang/AST/RecordLayout.h"
|
2009-06-14 09:54:56 +08:00
|
|
|
#include "clang/Basic/Builtins.h"
|
2009-03-28 11:45:20 +08:00
|
|
|
#include "clang/Basic/SourceManager.h"
|
2007-05-21 07:50:58 +08:00
|
|
|
#include "clang/Basic/TargetInfo.h"
|
2009-10-24 17:57:09 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2007-10-29 13:01:08 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2009-01-18 14:42:49 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2009-10-24 17:57:09 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-08-16 11:33:14 +08:00
|
|
|
#include "CXXABI.h"
|
2009-07-19 05:19:52 +08:00
|
|
|
|
2006-11-10 14:34:16 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
2010-07-03 08:47:00 +08:00
|
|
|
unsigned ASTContext::NumImplicitDefaultConstructors;
|
|
|
|
unsigned ASTContext::NumImplicitDefaultConstructorsDeclared;
|
2010-07-03 07:41:54 +08:00
|
|
|
unsigned ASTContext::NumImplicitCopyConstructors;
|
|
|
|
unsigned ASTContext::NumImplicitCopyConstructorsDeclared;
|
2010-07-03 05:50:04 +08:00
|
|
|
unsigned ASTContext::NumImplicitCopyAssignmentOperators;
|
|
|
|
unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
|
2010-07-03 04:37:36 +08:00
|
|
|
unsigned ASTContext::NumImplicitDestructors;
|
|
|
|
unsigned ASTContext::NumImplicitDestructorsDeclared;
|
|
|
|
|
2007-04-28 05:51:21 +08:00
|
|
|
enum FloatingRank {
|
|
|
|
FloatRank, DoubleRank, LongDoubleRank
|
|
|
|
};
|
|
|
|
|
2010-06-17 05:09:37 +08:00
|
|
|
void
|
|
|
|
ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
|
|
|
|
TemplateTemplateParmDecl *Parm) {
|
|
|
|
ID.AddInteger(Parm->getDepth());
|
|
|
|
ID.AddInteger(Parm->getPosition());
|
|
|
|
// FIXME: Parameter pack
|
|
|
|
|
|
|
|
TemplateParameterList *Params = Parm->getTemplateParameters();
|
|
|
|
ID.AddInteger(Params->size());
|
|
|
|
for (TemplateParameterList::const_iterator P = Params->begin(),
|
|
|
|
PEnd = Params->end();
|
|
|
|
P != PEnd; ++P) {
|
|
|
|
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
|
|
|
|
ID.AddInteger(0);
|
|
|
|
ID.AddBoolean(TTP->isParameterPack());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
|
|
|
|
ID.AddInteger(1);
|
|
|
|
// FIXME: Parameter pack
|
|
|
|
ID.AddPointer(NTTP->getType().getAsOpaquePtr());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
|
|
|
|
ID.AddInteger(2);
|
|
|
|
Profile(ID, TTP);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TemplateTemplateParmDecl *
|
|
|
|
ASTContext::getCanonicalTemplateTemplateParmDecl(
|
|
|
|
TemplateTemplateParmDecl *TTP) {
|
|
|
|
// Check if we already have a canonical template template parameter.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
CanonicalTemplateTemplateParm::Profile(ID, TTP);
|
|
|
|
void *InsertPos = 0;
|
|
|
|
CanonicalTemplateTemplateParm *Canonical
|
|
|
|
= CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
if (Canonical)
|
|
|
|
return Canonical->getParam();
|
|
|
|
|
|
|
|
// Build a canonical template parameter list.
|
|
|
|
TemplateParameterList *Params = TTP->getTemplateParameters();
|
|
|
|
llvm::SmallVector<NamedDecl *, 4> CanonParams;
|
|
|
|
CanonParams.reserve(Params->size());
|
|
|
|
for (TemplateParameterList::const_iterator P = Params->begin(),
|
|
|
|
PEnd = Params->end();
|
|
|
|
P != PEnd; ++P) {
|
|
|
|
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
|
|
|
|
CanonParams.push_back(
|
|
|
|
TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
|
|
|
|
SourceLocation(), TTP->getDepth(),
|
|
|
|
TTP->getIndex(), 0, false,
|
|
|
|
TTP->isParameterPack()));
|
|
|
|
else if (NonTypeTemplateParmDecl *NTTP
|
|
|
|
= dyn_cast<NonTypeTemplateParmDecl>(*P))
|
|
|
|
CanonParams.push_back(
|
|
|
|
NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
|
|
|
|
SourceLocation(), NTTP->getDepth(),
|
|
|
|
NTTP->getPosition(), 0,
|
|
|
|
getCanonicalType(NTTP->getType()),
|
|
|
|
0));
|
|
|
|
else
|
|
|
|
CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
|
|
|
|
cast<TemplateTemplateParmDecl>(*P)));
|
|
|
|
}
|
|
|
|
|
|
|
|
TemplateTemplateParmDecl *CanonTTP
|
|
|
|
= TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
|
|
|
|
SourceLocation(), TTP->getDepth(),
|
|
|
|
TTP->getPosition(), 0,
|
|
|
|
TemplateParameterList::Create(*this, SourceLocation(),
|
|
|
|
SourceLocation(),
|
|
|
|
CanonParams.data(),
|
|
|
|
CanonParams.size(),
|
|
|
|
SourceLocation()));
|
|
|
|
|
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(Canonical == 0 && "Shouldn't be in the map!");
|
|
|
|
(void)Canonical;
|
|
|
|
|
|
|
|
// Create the canonical template template parameter entry.
|
|
|
|
Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
|
|
|
|
CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
|
|
|
|
return CanonTTP;
|
|
|
|
}
|
|
|
|
|
2010-08-16 11:33:14 +08:00
|
|
|
CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
|
2010-08-22 06:46:04 +08:00
|
|
|
if (!LangOpts.CPlusPlus) return 0;
|
|
|
|
|
2010-08-19 10:18:14 +08:00
|
|
|
switch (T.getCXXABI()) {
|
2010-08-22 06:46:04 +08:00
|
|
|
case CXXABI_ARM:
|
|
|
|
return CreateARMCXXABI(*this);
|
|
|
|
case CXXABI_Itanium:
|
2010-08-16 11:33:14 +08:00
|
|
|
return CreateItaniumCXXABI(*this);
|
2010-08-19 10:18:14 +08:00
|
|
|
case CXXABI_Microsoft:
|
|
|
|
return CreateMicrosoftCXXABI(*this);
|
|
|
|
}
|
2010-08-22 06:46:04 +08:00
|
|
|
return 0;
|
2010-08-16 11:33:14 +08:00
|
|
|
}
|
|
|
|
|
2008-10-06 01:34:18 +08:00
|
|
|
ASTContext::ASTContext(const LangOptions& LOpts, SourceManager &SM,
|
2009-11-13 13:51:54 +08:00
|
|
|
const TargetInfo &t,
|
2008-08-11 12:54:23 +08:00
|
|
|
IdentifierTable &idents, SelectorTable &sels,
|
2009-06-14 09:54:56 +08:00
|
|
|
Builtin::Context &builtins,
|
2010-07-26 01:53:33 +08:00
|
|
|
unsigned size_reserve) :
|
2010-06-11 19:07:21 +08:00
|
|
|
TemplateSpecializationTypes(this_()),
|
|
|
|
DependentTemplateSpecializationTypes(this_()),
|
2010-07-05 05:44:19 +08:00
|
|
|
GlobalNestedNameSpecifier(0), IsInt128Installed(false),
|
|
|
|
CFConstantStringTypeDecl(0), NSConstantStringTypeDecl(0),
|
2009-07-28 10:25:19 +08:00
|
|
|
ObjCFastEnumerationStateTypeDecl(0), FILEDecl(0), jmp_bufDecl(0),
|
2009-10-22 08:49:09 +08:00
|
|
|
sigjmp_bufDecl(0), BlockDescriptorType(0), BlockDescriptorExtendedType(0),
|
2010-06-05 07:28:52 +08:00
|
|
|
NullTypeSourceInfo(QualType()),
|
2010-08-16 11:33:14 +08:00
|
|
|
SourceMgr(SM), LangOpts(LOpts), ABI(createCXXABI(t)), Target(t),
|
Add support for retrieving the Doxygen comment associated with a given
declaration in the AST.
The new ASTContext::getCommentForDecl function searches for a comment
that is attached to the given declaration, and returns that comment,
which may be composed of several comment blocks.
Comments are always available in an AST. However, to avoid harming
performance, we don't actually parse the comments. Rather, we keep the
source ranges of all of the comments within a large, sorted vector,
then lazily extract comments via a binary search in that vector only
when needed (which never occurs in a "normal" compile).
Comments are written to a precompiled header/AST file as a blob of
source ranges. That blob is only lazily loaded when one requests a
comment for a declaration (this never occurs in a "normal" compile).
The indexer testbed now supports comment extraction. When the
-point-at location points to a declaration with a Doxygen-style
comment, the indexer testbed prints the associated comment
block(s). See test/Index/comments.c for an example.
Some notes:
- We don't actually attempt to parse the comment blocks themselves,
beyond identifying them as Doxygen comment blocks to associate them
with a declaration.
- We won't find comment blocks that aren't adjacent to the
declaration, because we start our search based on the location of
the declaration.
- We don't go through the necessary hops to find, for example,
whether some redeclaration of a declaration has comments when our
current declaration does not. Similarly, we don't attempt to
associate a \param Foo marker in a function body comment with the
parameter named Foo (although that is certainly possible).
- Verification of my "no performance impact" claims is still "to be
done".
llvm-svn: 74704
2009-07-03 01:08:52 +08:00
|
|
|
Idents(idents), Selectors(sels),
|
2010-05-11 04:40:08 +08:00
|
|
|
BuiltinInfo(builtins),
|
|
|
|
DeclarationNames(*this),
|
|
|
|
ExternalSource(0), PrintingPolicy(LOpts),
|
2010-06-18 08:31:04 +08:00
|
|
|
LastSDM(0, 0),
|
|
|
|
UniqueBlockByRefTypeID(0), UniqueBlockParmTypeID(0) {
|
2009-08-18 00:35:33 +08:00
|
|
|
ObjCIdRedefinitionType = QualType();
|
|
|
|
ObjCClassRedefinitionType = QualType();
|
2010-07-26 01:53:33 +08:00
|
|
|
ObjCSelRedefinitionType = QualType();
|
2009-09-09 23:08:12 +08:00
|
|
|
if (size_reserve > 0) Types.reserve(size_reserve);
|
2008-08-11 12:54:23 +08:00
|
|
|
TUDecl = TranslationUnitDecl::Create(*this);
|
2009-07-11 07:34:53 +08:00
|
|
|
InitBuiltinTypes();
|
2008-08-11 12:54:23 +08:00
|
|
|
}
|
|
|
|
|
2006-11-12 08:53:46 +08:00
|
|
|
ASTContext::~ASTContext() {
|
2010-02-11 15:12:28 +08:00
|
|
|
// Release the DenseMaps associated with DeclContext objects.
|
|
|
|
// FIXME: Is this the ideal solution?
|
|
|
|
ReleaseDeclContextMaps();
|
2010-03-03 07:58:15 +08:00
|
|
|
|
2010-07-26 01:53:33 +08:00
|
|
|
// Call all of the deallocation functions.
|
|
|
|
for (unsigned I = 0, N = Deallocations.size(); I != N; ++I)
|
|
|
|
Deallocations[I].first(Deallocations[I].second);
|
2010-05-24 02:26:36 +08:00
|
|
|
|
2010-03-03 07:58:15 +08:00
|
|
|
// Release all of the memory associated with overridden C++ methods.
|
|
|
|
for (llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::iterator
|
|
|
|
OM = OverriddenMethods.begin(), OMEnd = OverriddenMethods.end();
|
|
|
|
OM != OMEnd; ++OM)
|
|
|
|
OM->second.Destroy();
|
2010-02-11 15:12:28 +08:00
|
|
|
|
2010-06-09 07:00:58 +08:00
|
|
|
// ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
|
2010-07-26 01:53:33 +08:00
|
|
|
// because they can contain DenseMaps.
|
|
|
|
for (llvm::DenseMap<const ObjCContainerDecl*,
|
|
|
|
const ASTRecordLayout*>::iterator
|
|
|
|
I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
|
|
|
|
// Increment in loop to prevent using deallocated memory.
|
|
|
|
if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second))
|
|
|
|
R->Destroy(*this);
|
|
|
|
|
2010-06-09 07:00:58 +08:00
|
|
|
for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
|
|
|
|
I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
|
|
|
|
// Increment in loop to prevent using deallocated memory.
|
|
|
|
if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second))
|
|
|
|
R->Destroy(*this);
|
|
|
|
}
|
2010-08-31 00:49:28 +08:00
|
|
|
|
|
|
|
for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
|
|
|
|
AEnd = DeclAttrs.end();
|
|
|
|
A != AEnd; ++A)
|
|
|
|
A->second->~AttrVec();
|
|
|
|
}
|
2009-03-27 07:50:42 +08:00
|
|
|
|
2010-05-24 02:26:36 +08:00
|
|
|
void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
|
|
|
|
Deallocations.push_back(std::make_pair(Callback, Data));
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
void
|
2009-04-10 06:27:44 +08:00
|
|
|
ASTContext::setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source) {
|
|
|
|
ExternalSource.reset(Source.take());
|
|
|
|
}
|
|
|
|
|
2007-01-26 09:27:23 +08:00
|
|
|
void ASTContext::PrintStats() const {
|
|
|
|
fprintf(stderr, "*** AST Context Stats:\n");
|
|
|
|
fprintf(stderr, " %d types total.\n", (int)Types.size());
|
2009-03-17 07:22:08 +08:00
|
|
|
|
2009-05-26 22:40:08 +08:00
|
|
|
unsigned counts[] = {
|
2009-09-09 23:08:12 +08:00
|
|
|
#define TYPE(Name, Parent) 0,
|
2009-05-26 22:40:08 +08:00
|
|
|
#define ABSTRACT_TYPE(Name, Parent)
|
|
|
|
#include "clang/AST/TypeNodes.def"
|
|
|
|
0 // Extra
|
|
|
|
};
|
2009-04-08 01:20:56 +08:00
|
|
|
|
2007-01-26 09:27:23 +08:00
|
|
|
for (unsigned i = 0, e = Types.size(); i != e; ++i) {
|
|
|
|
Type *T = Types[i];
|
2009-05-26 22:40:08 +08:00
|
|
|
counts[(unsigned)T->getTypeClass()]++;
|
2007-01-26 09:27:23 +08:00
|
|
|
}
|
|
|
|
|
2009-05-26 22:40:08 +08:00
|
|
|
unsigned Idx = 0;
|
|
|
|
unsigned TotalBytes = 0;
|
|
|
|
#define TYPE(Name, Parent) \
|
|
|
|
if (counts[Idx]) \
|
|
|
|
fprintf(stderr, " %d %s types\n", (int)counts[Idx], #Name); \
|
|
|
|
TotalBytes += counts[Idx] * sizeof(Name##Type); \
|
|
|
|
++Idx;
|
|
|
|
#define ABSTRACT_TYPE(Name, Parent)
|
|
|
|
#include "clang/AST/TypeNodes.def"
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-26 22:40:08 +08:00
|
|
|
fprintf(stderr, "Total bytes = %d\n", int(TotalBytes));
|
2010-07-08 14:14:04 +08:00
|
|
|
|
2010-07-03 04:37:36 +08:00
|
|
|
// Implicit special member functions.
|
2010-07-03 08:47:00 +08:00
|
|
|
fprintf(stderr, " %u/%u implicit default constructors created\n",
|
|
|
|
NumImplicitDefaultConstructorsDeclared,
|
|
|
|
NumImplicitDefaultConstructors);
|
2010-07-03 07:41:54 +08:00
|
|
|
fprintf(stderr, " %u/%u implicit copy constructors created\n",
|
|
|
|
NumImplicitCopyConstructorsDeclared,
|
|
|
|
NumImplicitCopyConstructors);
|
2010-07-03 05:50:04 +08:00
|
|
|
fprintf(stderr, " %u/%u implicit copy assignment operators created\n",
|
|
|
|
NumImplicitCopyAssignmentOperatorsDeclared,
|
|
|
|
NumImplicitCopyAssignmentOperators);
|
2010-07-03 04:37:36 +08:00
|
|
|
fprintf(stderr, " %u/%u implicit destructors created\n",
|
|
|
|
NumImplicitDestructorsDeclared, NumImplicitDestructors);
|
|
|
|
|
2009-04-10 06:27:44 +08:00
|
|
|
if (ExternalSource.get()) {
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
ExternalSource->PrintStats();
|
|
|
|
}
|
2010-07-08 14:14:04 +08:00
|
|
|
|
2010-07-26 01:53:33 +08:00
|
|
|
BumpAlloc.PrintStats();
|
2007-01-26 09:27:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-24 07:03:21 +08:00
|
|
|
void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
|
2009-09-25 07:30:46 +08:00
|
|
|
BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K);
|
2009-10-24 07:03:21 +08:00
|
|
|
R = CanQualType::CreateUnsafe(QualType(Ty, 0));
|
2009-09-25 07:30:46 +08:00
|
|
|
Types.push_back(Ty);
|
2006-11-12 08:53:46 +08:00
|
|
|
}
|
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
void ASTContext::InitBuiltinTypes() {
|
|
|
|
assert(VoidTy.isNull() && "Context reinitialized?");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p19.
|
2006-12-03 10:57:32 +08:00
|
|
|
InitBuiltinType(VoidTy, BuiltinType::Void);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p2.
|
2006-12-03 10:57:32 +08:00
|
|
|
InitBuiltinType(BoolTy, BuiltinType::Bool);
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p3.
|
2009-06-05 15:05:05 +08:00
|
|
|
if (LangOpts.CharIsSigned)
|
2007-06-03 15:25:34 +08:00
|
|
|
InitBuiltinType(CharTy, BuiltinType::Char_S);
|
|
|
|
else
|
|
|
|
InitBuiltinType(CharTy, BuiltinType::Char_U);
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p4.
|
2006-12-03 10:57:32 +08:00
|
|
|
InitBuiltinType(SignedCharTy, BuiltinType::SChar);
|
|
|
|
InitBuiltinType(ShortTy, BuiltinType::Short);
|
|
|
|
InitBuiltinType(IntTy, BuiltinType::Int);
|
|
|
|
InitBuiltinType(LongTy, BuiltinType::Long);
|
|
|
|
InitBuiltinType(LongLongTy, BuiltinType::LongLong);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p6.
|
2006-12-03 10:57:32 +08:00
|
|
|
InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
|
|
|
|
InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
|
|
|
|
InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
|
|
|
|
InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
|
|
|
|
InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p10.
|
2006-12-03 10:57:32 +08:00
|
|
|
InitBuiltinType(FloatTy, BuiltinType::Float);
|
|
|
|
InitBuiltinType(DoubleTy, BuiltinType::Double);
|
|
|
|
InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
|
2008-08-10 00:51:54 +08:00
|
|
|
|
2009-04-30 10:43:43 +08:00
|
|
|
// GNU extension, 128-bit integers.
|
|
|
|
InitBuiltinType(Int128Ty, BuiltinType::Int128);
|
|
|
|
InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
|
|
|
|
|
2009-02-27 07:43:47 +08:00
|
|
|
if (LangOpts.CPlusPlus) // C++ 3.9.1p5
|
|
|
|
InitBuiltinType(WCharTy, BuiltinType::WChar);
|
|
|
|
else // C99
|
|
|
|
WCharTy = getFromTargetType(Target.getWCharType());
|
2008-08-10 00:51:54 +08:00
|
|
|
|
2009-07-14 14:30:34 +08:00
|
|
|
if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
|
|
|
|
InitBuiltinType(Char16Ty, BuiltinType::Char16);
|
|
|
|
else // C99
|
|
|
|
Char16Ty = getFromTargetType(Target.getChar16Type());
|
|
|
|
|
|
|
|
if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
|
|
|
|
InitBuiltinType(Char32Ty, BuiltinType::Char32);
|
|
|
|
else // C99
|
|
|
|
Char32Ty = getFromTargetType(Target.getChar32Type());
|
|
|
|
|
2008-12-06 07:32:09 +08:00
|
|
|
// Placeholder type for type-dependent expressions whose type is
|
|
|
|
// completely unknown. No code should ever check a type against
|
|
|
|
// DependentTy and users should never see it; however, it is here to
|
|
|
|
// help diagnose failures to properly check for type-dependent
|
|
|
|
// expressions.
|
|
|
|
InitBuiltinType(DependentTy, BuiltinType::Dependent);
|
2008-10-22 00:13:35 +08:00
|
|
|
|
2010-10-12 08:20:44 +08:00
|
|
|
// Placeholder type for functions.
|
|
|
|
InitBuiltinType(OverloadTy, BuiltinType::Overload);
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
// Placeholder type for C++0x auto declarations whose real type has
|
2009-06-27 02:41:36 +08:00
|
|
|
// not yet been deduced.
|
2010-10-12 08:20:44 +08:00
|
|
|
InitBuiltinType(UndeducedAutoTy, BuiltinType::UndeducedAuto);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
// C99 6.2.5p11.
|
2007-06-23 04:56:16 +08:00
|
|
|
FloatComplexTy = getComplexType(FloatTy);
|
|
|
|
DoubleComplexTy = getComplexType(DoubleTy);
|
|
|
|
LongDoubleComplexTy = getComplexType(LongDoubleTy);
|
2008-10-22 00:13:35 +08:00
|
|
|
|
2007-10-15 22:41:52 +08:00
|
|
|
BuiltinVaListType = QualType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-16 02:40:39 +08:00
|
|
|
// "Builtin" typedefs set by Sema::ActOnTranslationUnitScope().
|
|
|
|
ObjCIdTypedefType = QualType();
|
|
|
|
ObjCClassTypedefType = QualType();
|
2009-11-22 03:53:08 +08:00
|
|
|
ObjCSelTypedefType = QualType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-22 03:53:08 +08:00
|
|
|
// Builtin types for 'id', 'Class', and 'SEL'.
|
2009-07-16 02:40:39 +08:00
|
|
|
InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
|
|
|
|
InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
|
2009-11-22 03:53:08 +08:00
|
|
|
InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
|
2009-07-11 07:34:53 +08:00
|
|
|
|
2008-01-08 03:49:32 +08:00
|
|
|
ObjCConstantStringType = QualType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-30 06:57:28 +08:00
|
|
|
// void * type
|
|
|
|
VoidPtrTy = getPointerType(VoidTy);
|
2009-05-11 02:38:11 +08:00
|
|
|
|
|
|
|
// nullptr type (C++0x 2.14.7)
|
|
|
|
InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
|
2006-11-12 08:37:36 +08:00
|
|
|
}
|
|
|
|
|
2010-09-22 22:32:24 +08:00
|
|
|
Diagnostic &ASTContext::getDiagnostics() const {
|
|
|
|
return SourceMgr.getDiagnostics();
|
|
|
|
}
|
|
|
|
|
2010-08-31 00:49:28 +08:00
|
|
|
AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
|
|
|
|
AttrVec *&Result = DeclAttrs[D];
|
|
|
|
if (!Result) {
|
|
|
|
void *Mem = Allocate(sizeof(AttrVec));
|
|
|
|
Result = new (Mem) AttrVec;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Erase the attributes corresponding to the given declaration.
|
|
|
|
void ASTContext::eraseDeclAttrs(const Decl *D) {
|
|
|
|
llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
|
|
|
|
if (Pos != DeclAttrs.end()) {
|
|
|
|
Pos->second->~AttrVec();
|
|
|
|
DeclAttrs.erase(Pos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-08 15:24:58 +08:00
|
|
|
MemberSpecializationInfo *
|
2009-10-15 04:14:33 +08:00
|
|
|
ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
|
2009-07-25 04:34:43 +08:00
|
|
|
assert(Var->isStaticDataMember() && "Not a static data member");
|
2009-10-15 04:14:33 +08:00
|
|
|
llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos
|
2009-07-25 04:34:43 +08:00
|
|
|
= InstantiatedFromStaticDataMember.find(Var);
|
|
|
|
if (Pos == InstantiatedFromStaticDataMember.end())
|
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-25 04:34:43 +08:00
|
|
|
return Pos->second;
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
void
|
2009-10-08 15:24:58 +08:00
|
|
|
ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
|
2010-07-05 05:44:00 +08:00
|
|
|
TemplateSpecializationKind TSK,
|
|
|
|
SourceLocation PointOfInstantiation) {
|
2009-07-25 04:34:43 +08:00
|
|
|
assert(Inst->isStaticDataMember() && "Not a static data member");
|
|
|
|
assert(Tmpl->isStaticDataMember() && "Not a static data member");
|
|
|
|
assert(!InstantiatedFromStaticDataMember[Inst] &&
|
|
|
|
"Already noted what static data member was instantiated from");
|
2009-10-08 15:24:58 +08:00
|
|
|
InstantiatedFromStaticDataMember[Inst]
|
2010-07-05 05:44:00 +08:00
|
|
|
= new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation);
|
2009-07-25 04:34:43 +08:00
|
|
|
}
|
|
|
|
|
2009-11-18 10:36:19 +08:00
|
|
|
NamedDecl *
|
2009-12-05 06:46:56 +08:00
|
|
|
ASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) {
|
2009-11-18 10:36:19 +08:00
|
|
|
llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos
|
2009-12-05 06:46:56 +08:00
|
|
|
= InstantiatedFromUsingDecl.find(UUD);
|
|
|
|
if (Pos == InstantiatedFromUsingDecl.end())
|
2009-08-30 03:37:28 +08:00
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-08-30 03:37:28 +08:00
|
|
|
return Pos->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-12-05 06:46:56 +08:00
|
|
|
ASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) {
|
|
|
|
assert((isa<UsingDecl>(Pattern) ||
|
|
|
|
isa<UnresolvedUsingValueDecl>(Pattern) ||
|
|
|
|
isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
|
|
|
|
"pattern decl is not a using decl");
|
|
|
|
assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
|
|
|
|
InstantiatedFromUsingDecl[Inst] = Pattern;
|
|
|
|
}
|
|
|
|
|
|
|
|
UsingShadowDecl *
|
|
|
|
ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
|
|
|
|
llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
|
|
|
|
= InstantiatedFromUsingShadowDecl.find(Inst);
|
|
|
|
if (Pos == InstantiatedFromUsingShadowDecl.end())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return Pos->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
|
|
|
|
UsingShadowDecl *Pattern) {
|
|
|
|
assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
|
|
|
|
InstantiatedFromUsingShadowDecl[Inst] = Pattern;
|
2009-08-30 03:37:28 +08:00
|
|
|
}
|
|
|
|
|
2009-09-01 12:26:58 +08:00
|
|
|
FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
|
|
|
|
llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
|
|
|
|
= InstantiatedFromUnnamedFieldDecl.find(Field);
|
|
|
|
if (Pos == InstantiatedFromUnnamedFieldDecl.end())
|
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-01 12:26:58 +08:00
|
|
|
return Pos->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst,
|
|
|
|
FieldDecl *Tmpl) {
|
|
|
|
assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed");
|
|
|
|
assert(!Tmpl->getDeclName() && "Template field decl is not unnamed");
|
|
|
|
assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
|
|
|
|
"Already noted what unnamed field was instantiated from");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-01 12:26:58 +08:00
|
|
|
InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
|
|
|
|
}
|
|
|
|
|
2010-03-03 07:58:15 +08:00
|
|
|
ASTContext::overridden_cxx_method_iterator
|
|
|
|
ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const {
|
|
|
|
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos
|
|
|
|
= OverriddenMethods.find(Method);
|
|
|
|
if (Pos == OverriddenMethods.end())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return Pos->second.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
ASTContext::overridden_cxx_method_iterator
|
|
|
|
ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const {
|
|
|
|
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos
|
|
|
|
= OverriddenMethods.find(Method);
|
|
|
|
if (Pos == OverriddenMethods.end())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return Pos->second.end();
|
|
|
|
}
|
|
|
|
|
2010-07-05 05:44:35 +08:00
|
|
|
unsigned
|
|
|
|
ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const {
|
|
|
|
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos
|
|
|
|
= OverriddenMethods.find(Method);
|
|
|
|
if (Pos == OverriddenMethods.end())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return Pos->second.size();
|
|
|
|
}
|
|
|
|
|
2010-03-03 07:58:15 +08:00
|
|
|
void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method,
|
|
|
|
const CXXMethodDecl *Overridden) {
|
|
|
|
OverriddenMethods[Method].push_back(Overridden);
|
|
|
|
}
|
|
|
|
|
2007-07-19 01:52:12 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Type Sizing and Analysis
|
|
|
|
//===----------------------------------------------------------------------===//
|
2007-07-14 06:13:22 +08:00
|
|
|
|
2008-07-01 02:32:54 +08:00
|
|
|
/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
|
|
|
|
/// scalar floating point type.
|
|
|
|
const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
|
2009-09-22 07:43:11 +08:00
|
|
|
const BuiltinType *BT = T->getAs<BuiltinType>();
|
2008-07-01 02:32:54 +08:00
|
|
|
assert(BT && "Not a floating point type!");
|
|
|
|
switch (BT->getKind()) {
|
|
|
|
default: assert(0 && "Not a floating point type!");
|
|
|
|
case BuiltinType::Float: return Target.getFloatFormat();
|
|
|
|
case BuiltinType::Double: return Target.getDoubleFormat();
|
|
|
|
case BuiltinType::LongDouble: return Target.getLongDoubleFormat();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-28 01:10:57 +08:00
|
|
|
/// getDeclAlign - Return a conservative estimate of the alignment of the
|
2009-01-25 05:53:27 +08:00
|
|
|
/// specified decl. Note that bitfields do not have a valid alignment, so
|
|
|
|
/// this method will assert on them.
|
2009-11-24 01:18:46 +08:00
|
|
|
/// If @p RefAsPointee, references are treated like their underlying type
|
|
|
|
/// (for alignof), else they're treated like pointers (for CodeGen).
|
2010-01-28 01:10:57 +08:00
|
|
|
CharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) {
|
2009-02-22 10:56:25 +08:00
|
|
|
unsigned Align = Target.getCharWidth();
|
|
|
|
|
2010-10-09 02:24:19 +08:00
|
|
|
bool UseAlignAttrOnly = false;
|
|
|
|
if (unsigned AlignFromAttr = D->getMaxAlignment()) {
|
|
|
|
Align = AlignFromAttr;
|
|
|
|
|
|
|
|
// __attribute__((aligned)) can increase or decrease alignment
|
|
|
|
// *except* on a struct or struct member, where it only increases
|
|
|
|
// alignment unless 'packed' is also specified.
|
|
|
|
//
|
|
|
|
// It is an error for [[align]] to decrease alignment, so we can
|
|
|
|
// ignore that possibility; Sema should diagnose it.
|
|
|
|
if (isa<FieldDecl>(D)) {
|
|
|
|
UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
|
|
|
|
cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
|
|
|
|
} else {
|
|
|
|
UseAlignAttrOnly = true;
|
|
|
|
}
|
|
|
|
}
|
2009-02-22 10:56:25 +08:00
|
|
|
|
2010-10-09 02:24:19 +08:00
|
|
|
if (UseAlignAttrOnly) {
|
|
|
|
// ignore type of value
|
|
|
|
} else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
|
2009-01-25 05:53:27 +08:00
|
|
|
QualType T = VD->getType();
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const ReferenceType* RT = T->getAs<ReferenceType>()) {
|
2009-11-24 01:18:46 +08:00
|
|
|
if (RefAsPointee)
|
|
|
|
T = RT->getPointeeType();
|
|
|
|
else
|
|
|
|
T = getPointerType(RT->getPointeeType());
|
|
|
|
}
|
|
|
|
if (!T->isIncompleteType() && !T->isFunctionType()) {
|
2010-06-05 07:15:27 +08:00
|
|
|
unsigned MinWidth = Target.getLargeArrayMinWidth();
|
|
|
|
unsigned ArrayAlign = Target.getLargeArrayAlign();
|
|
|
|
if (isa<VariableArrayType>(T) && MinWidth != 0)
|
|
|
|
Align = std::max(Align, ArrayAlign);
|
|
|
|
if (ConstantArrayType *CT = dyn_cast<ConstantArrayType>(T)) {
|
|
|
|
unsigned Size = getTypeSize(CT);
|
|
|
|
if (MinWidth != 0 && MinWidth <= Size)
|
|
|
|
Align = std::max(Align, ArrayAlign);
|
|
|
|
}
|
2009-04-10 12:47:03 +08:00
|
|
|
// Incomplete or function types default to 1.
|
2009-02-22 10:56:25 +08:00
|
|
|
while (isa<VariableArrayType>(T) || isa<IncompleteArrayType>(T))
|
|
|
|
T = cast<ArrayType>(T)->getElementType();
|
|
|
|
|
|
|
|
Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
|
|
|
|
}
|
2010-02-23 12:52:00 +08:00
|
|
|
if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) {
|
|
|
|
// In the case of a field in a packed struct, we want the minimum
|
|
|
|
// of the alignment of the field and the alignment of the struct.
|
|
|
|
Align = std::min(Align,
|
|
|
|
getPreferredTypeAlign(FD->getParent()->getTypeForDecl()));
|
|
|
|
}
|
2009-01-25 05:53:27 +08:00
|
|
|
}
|
2009-02-22 10:56:25 +08:00
|
|
|
|
2010-01-28 01:10:57 +08:00
|
|
|
return CharUnits::fromQuantity(Align / Target.getCharWidth());
|
2009-01-25 05:53:27 +08:00
|
|
|
}
|
2008-07-01 02:32:54 +08:00
|
|
|
|
2010-05-20 09:18:31 +08:00
|
|
|
std::pair<CharUnits, CharUnits>
|
|
|
|
ASTContext::getTypeInfoInChars(const Type *T) {
|
|
|
|
std::pair<uint64_t, unsigned> Info = getTypeInfo(T);
|
|
|
|
return std::make_pair(CharUnits::fromQuantity(Info.first / getCharWidth()),
|
|
|
|
CharUnits::fromQuantity(Info.second / getCharWidth()));
|
|
|
|
}
|
|
|
|
|
|
|
|
std::pair<CharUnits, CharUnits>
|
|
|
|
ASTContext::getTypeInfoInChars(QualType T) {
|
|
|
|
return getTypeInfoInChars(T.getTypePtr());
|
|
|
|
}
|
|
|
|
|
2007-07-14 06:13:22 +08:00
|
|
|
/// getTypeSize - Return the size of the specified type, in bits. This method
|
|
|
|
/// does not work on incomplete types.
|
2009-09-25 03:53:00 +08:00
|
|
|
///
|
|
|
|
/// FIXME: Pointers into different addr spaces could have different sizes and
|
|
|
|
/// alignment requirements: getPointerInfo should take an AddrSpace, this
|
|
|
|
/// should take a QualType, &c.
|
2007-07-14 09:29:45 +08:00
|
|
|
std::pair<uint64_t, unsigned>
|
2008-11-08 13:48:37 +08:00
|
|
|
ASTContext::getTypeInfo(const Type *T) {
|
2009-02-28 02:32:39 +08:00
|
|
|
uint64_t Width=0;
|
|
|
|
unsigned Align=8;
|
2007-07-14 06:13:22 +08:00
|
|
|
switch (T->getTypeClass()) {
|
2009-02-27 07:50:07 +08:00
|
|
|
#define TYPE(Class, Base)
|
|
|
|
#define ABSTRACT_TYPE(Class, Base)
|
2009-05-01 01:32:17 +08:00
|
|
|
#define NON_CANONICAL_TYPE(Class, Base)
|
2009-02-27 07:50:07 +08:00
|
|
|
#define DEPENDENT_TYPE(Class, Base) case Type::Class:
|
|
|
|
#include "clang/AST/TypeNodes.def"
|
2009-05-01 01:32:17 +08:00
|
|
|
assert(false && "Should not see dependent types");
|
2009-02-27 07:50:07 +08:00
|
|
|
break;
|
|
|
|
|
2007-07-19 02:26:58 +08:00
|
|
|
case Type::FunctionNoProto:
|
|
|
|
case Type::FunctionProto:
|
2009-05-01 01:32:17 +08:00
|
|
|
// GCC extension: alignof(function) = 32 bits
|
|
|
|
Width = 0;
|
|
|
|
Align = 32;
|
|
|
|
break;
|
|
|
|
|
2009-02-27 07:50:07 +08:00
|
|
|
case Type::IncompleteArray:
|
2007-08-30 09:06:46 +08:00
|
|
|
case Type::VariableArray:
|
2009-05-01 01:32:17 +08:00
|
|
|
Width = 0;
|
|
|
|
Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
|
|
|
|
break;
|
|
|
|
|
2007-08-30 09:06:46 +08:00
|
|
|
case Type::ConstantArray: {
|
2008-11-08 13:48:37 +08:00
|
|
|
const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-03-06 02:54:05 +08:00
|
|
|
std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType());
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = EltInfo.first*CAT->getSize().getZExtValue();
|
2007-07-20 06:06:24 +08:00
|
|
|
Align = EltInfo.second;
|
|
|
|
break;
|
2007-12-29 13:10:55 +08:00
|
|
|
}
|
2008-04-19 07:10:10 +08:00
|
|
|
case Type::ExtVector:
|
2007-07-20 06:06:24 +08:00
|
|
|
case Type::Vector: {
|
2009-10-22 13:17:15 +08:00
|
|
|
const VectorType *VT = cast<VectorType>(T);
|
|
|
|
std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType());
|
|
|
|
Width = EltInfo.first*VT->getNumElements();
|
2008-05-30 17:31:38 +08:00
|
|
|
Align = Width;
|
2009-01-18 14:42:49 +08:00
|
|
|
// If the alignment is not a power of 2, round up to the next power of 2.
|
|
|
|
// This happens for non-power-of-2 length vectors.
|
2010-04-22 07:32:43 +08:00
|
|
|
if (Align & (Align-1)) {
|
2009-10-22 13:17:15 +08:00
|
|
|
Align = llvm::NextPowerOf2(Align);
|
|
|
|
Width = llvm::RoundUpToAlignment(Width, Align);
|
|
|
|
}
|
2007-07-20 06:06:24 +08:00
|
|
|
break;
|
|
|
|
}
|
2007-07-19 02:26:58 +08:00
|
|
|
|
2008-03-08 16:52:55 +08:00
|
|
|
case Type::Builtin:
|
2007-07-14 06:13:22 +08:00
|
|
|
switch (cast<BuiltinType>(T)->getKind()) {
|
2007-07-14 06:27:08 +08:00
|
|
|
default: assert(0 && "Unknown builtin type!");
|
2007-07-14 09:29:45 +08:00
|
|
|
case BuiltinType::Void:
|
2009-05-01 01:32:17 +08:00
|
|
|
// GCC extension: alignof(void) = 8 bits.
|
|
|
|
Width = 0;
|
|
|
|
Align = 8;
|
|
|
|
break;
|
|
|
|
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::Bool:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getBoolWidth();
|
|
|
|
Align = Target.getBoolAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2007-07-14 06:27:08 +08:00
|
|
|
case BuiltinType::Char_S:
|
|
|
|
case BuiltinType::Char_U:
|
|
|
|
case BuiltinType::UChar:
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::SChar:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getCharWidth();
|
|
|
|
Align = Target.getCharAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2008-08-10 00:51:54 +08:00
|
|
|
case BuiltinType::WChar:
|
|
|
|
Width = Target.getWCharWidth();
|
|
|
|
Align = Target.getWCharAlign();
|
|
|
|
break;
|
2009-07-14 14:30:34 +08:00
|
|
|
case BuiltinType::Char16:
|
|
|
|
Width = Target.getChar16Width();
|
|
|
|
Align = Target.getChar16Align();
|
|
|
|
break;
|
|
|
|
case BuiltinType::Char32:
|
|
|
|
Width = Target.getChar32Width();
|
|
|
|
Align = Target.getChar32Align();
|
|
|
|
break;
|
2007-07-14 06:27:08 +08:00
|
|
|
case BuiltinType::UShort:
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::Short:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getShortWidth();
|
|
|
|
Align = Target.getShortAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2007-07-14 06:27:08 +08:00
|
|
|
case BuiltinType::UInt:
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::Int:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getIntWidth();
|
|
|
|
Align = Target.getIntAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2007-07-14 06:27:08 +08:00
|
|
|
case BuiltinType::ULong:
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::Long:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getLongWidth();
|
|
|
|
Align = Target.getLongAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2007-07-14 06:27:08 +08:00
|
|
|
case BuiltinType::ULongLong:
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::LongLong:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getLongLongWidth();
|
|
|
|
Align = Target.getLongLongAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2009-04-30 10:55:13 +08:00
|
|
|
case BuiltinType::Int128:
|
|
|
|
case BuiltinType::UInt128:
|
|
|
|
Width = 128;
|
|
|
|
Align = 128; // int128_t is 128-bit aligned on all targets.
|
|
|
|
break;
|
2007-12-20 03:23:28 +08:00
|
|
|
case BuiltinType::Float:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getFloatWidth();
|
|
|
|
Align = Target.getFloatAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
|
|
|
case BuiltinType::Double:
|
2008-04-07 15:01:58 +08:00
|
|
|
Width = Target.getDoubleWidth();
|
|
|
|
Align = Target.getDoubleAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
|
|
|
case BuiltinType::LongDouble:
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = Target.getLongDoubleWidth();
|
|
|
|
Align = Target.getLongDoubleAlign();
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2009-05-11 02:38:11 +08:00
|
|
|
case BuiltinType::NullPtr:
|
|
|
|
Width = Target.getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
|
|
|
|
Align = Target.getPointerAlign(0); // == sizeof(void*)
|
2009-05-28 03:34:06 +08:00
|
|
|
break;
|
2010-08-03 02:03:20 +08:00
|
|
|
case BuiltinType::ObjCId:
|
|
|
|
case BuiltinType::ObjCClass:
|
|
|
|
case BuiltinType::ObjCSel:
|
|
|
|
Width = Target.getPointerWidth(0);
|
|
|
|
Align = Target.getPointerAlign(0);
|
|
|
|
break;
|
2007-07-14 06:13:22 +08:00
|
|
|
}
|
2007-07-16 07:46:53 +08:00
|
|
|
break;
|
2009-06-18 06:40:22 +08:00
|
|
|
case Type::ObjCObjectPointer:
|
2008-04-07 15:01:58 +08:00
|
|
|
Width = Target.getPointerWidth(0);
|
2008-03-08 16:34:58 +08:00
|
|
|
Align = Target.getPointerAlign(0);
|
2007-12-20 03:23:28 +08:00
|
|
|
break;
|
2008-09-24 23:05:44 +08:00
|
|
|
case Type::BlockPointer: {
|
|
|
|
unsigned AS = cast<BlockPointerType>(T)->getPointeeType().getAddressSpace();
|
|
|
|
Width = Target.getPointerWidth(AS);
|
|
|
|
Align = Target.getPointerAlign(AS);
|
|
|
|
break;
|
|
|
|
}
|
2009-11-24 01:18:46 +08:00
|
|
|
case Type::LValueReference:
|
|
|
|
case Type::RValueReference: {
|
|
|
|
// alignof and sizeof should never enter this code path here, so we go
|
|
|
|
// the pointer route.
|
|
|
|
unsigned AS = cast<ReferenceType>(T)->getPointeeType().getAddressSpace();
|
|
|
|
Width = Target.getPointerWidth(AS);
|
|
|
|
Align = Target.getPointerAlign(AS);
|
|
|
|
break;
|
|
|
|
}
|
2008-03-08 16:34:58 +08:00
|
|
|
case Type::Pointer: {
|
|
|
|
unsigned AS = cast<PointerType>(T)->getPointeeType().getAddressSpace();
|
2008-04-07 15:01:58 +08:00
|
|
|
Width = Target.getPointerWidth(AS);
|
2008-03-08 16:34:58 +08:00
|
|
|
Align = Target.getPointerAlign(AS);
|
|
|
|
break;
|
|
|
|
}
|
2009-01-25 05:16:55 +08:00
|
|
|
case Type::MemberPointer: {
|
2010-08-16 11:33:14 +08:00
|
|
|
const MemberPointerType *MPT = cast<MemberPointerType>(T);
|
2009-09-09 23:08:12 +08:00
|
|
|
std::pair<uint64_t, unsigned> PtrDiffInfo =
|
2009-05-17 10:06:04 +08:00
|
|
|
getTypeInfo(getPointerDiffType());
|
2010-08-16 11:33:14 +08:00
|
|
|
Width = PtrDiffInfo.first * ABI->getMemberPointerSize(MPT);
|
2009-05-17 10:06:04 +08:00
|
|
|
Align = PtrDiffInfo.second;
|
|
|
|
break;
|
2009-01-25 05:16:55 +08:00
|
|
|
}
|
2007-07-19 02:26:58 +08:00
|
|
|
case Type::Complex: {
|
|
|
|
// Complex types have the same alignment as their elements, but twice the
|
|
|
|
// size.
|
2009-09-09 23:08:12 +08:00
|
|
|
std::pair<uint64_t, unsigned> EltInfo =
|
2008-03-06 02:54:05 +08:00
|
|
|
getTypeInfo(cast<ComplexType>(T)->getElementType());
|
2008-03-08 16:52:55 +08:00
|
|
|
Width = EltInfo.first*2;
|
2007-07-19 02:26:58 +08:00
|
|
|
Align = EltInfo.second;
|
|
|
|
break;
|
|
|
|
}
|
2010-05-15 19:32:37 +08:00
|
|
|
case Type::ObjCObject:
|
|
|
|
return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
|
2008-06-05 05:54:36 +08:00
|
|
|
case Type::ObjCInterface: {
|
2008-11-08 13:48:37 +08:00
|
|
|
const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T);
|
2008-06-05 05:54:36 +08:00
|
|
|
const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
|
|
|
|
Width = Layout.getSize();
|
|
|
|
Align = Layout.getAlignment();
|
|
|
|
break;
|
|
|
|
}
|
2009-02-27 07:50:07 +08:00
|
|
|
case Type::Record:
|
|
|
|
case Type::Enum: {
|
2008-11-08 13:48:37 +08:00
|
|
|
const TagType *TT = cast<TagType>(T);
|
|
|
|
|
|
|
|
if (TT->getDecl()->isInvalidDecl()) {
|
2008-08-10 05:35:13 +08:00
|
|
|
Width = 1;
|
|
|
|
Align = 1;
|
|
|
|
break;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-11-08 13:48:37 +08:00
|
|
|
if (const EnumType *ET = dyn_cast<EnumType>(TT))
|
2008-04-07 06:05:18 +08:00
|
|
|
return getTypeInfo(ET->getDecl()->getIntegerType());
|
|
|
|
|
2008-11-08 13:48:37 +08:00
|
|
|
const RecordType *RT = cast<RecordType>(TT);
|
2008-04-07 06:05:18 +08:00
|
|
|
const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl());
|
|
|
|
Width = Layout.getSize();
|
|
|
|
Align = Layout.getAlignment();
|
2007-07-24 06:46:22 +08:00
|
|
|
break;
|
2007-07-14 06:13:22 +08:00
|
|
|
}
|
2009-03-31 06:58:21 +08:00
|
|
|
|
2009-10-22 13:17:15 +08:00
|
|
|
case Type::SubstTemplateTypeParm:
|
2009-10-18 17:09:24 +08:00
|
|
|
return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
|
|
|
|
getReplacementType().getTypePtr());
|
|
|
|
|
2009-05-01 01:32:17 +08:00
|
|
|
case Type::Typedef: {
|
|
|
|
const TypedefDecl *Typedef = cast<TypedefType>(T)->getDecl();
|
2010-08-27 08:11:28 +08:00
|
|
|
std::pair<uint64_t, unsigned> Info
|
|
|
|
= getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
|
|
|
|
Align = std::max(Typedef->getMaxAlignment(), Info.second);
|
|
|
|
Width = Info.first;
|
2009-03-31 06:58:21 +08:00
|
|
|
break;
|
2008-04-07 06:05:18 +08:00
|
|
|
}
|
2009-05-01 01:32:17 +08:00
|
|
|
|
|
|
|
case Type::TypeOfExpr:
|
|
|
|
return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType()
|
|
|
|
.getTypePtr());
|
|
|
|
|
|
|
|
case Type::TypeOf:
|
|
|
|
return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr());
|
|
|
|
|
2009-06-25 03:06:50 +08:00
|
|
|
case Type::Decltype:
|
|
|
|
return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType()
|
|
|
|
.getTypePtr());
|
|
|
|
|
2010-05-12 05:36:43 +08:00
|
|
|
case Type::Elaborated:
|
|
|
|
return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-01 01:32:17 +08:00
|
|
|
case Type::TemplateSpecialization:
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(getCanonicalType(T) != T &&
|
2009-05-01 01:32:17 +08:00
|
|
|
"Cannot request the size of a dependent type");
|
|
|
|
// FIXME: this is likely to be wrong once we support template
|
|
|
|
// aliases, since a template alias could refer to a typedef that
|
|
|
|
// has an __aligned__ attribute on it.
|
|
|
|
return getTypeInfo(getCanonicalType(T));
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-07-19 01:52:12 +08:00
|
|
|
assert(Align && (Align & (Align-1)) == 0 && "Alignment must be power of 2");
|
2008-03-08 16:52:55 +08:00
|
|
|
return std::make_pair(Width, Align);
|
2007-07-14 06:13:22 +08:00
|
|
|
}
|
|
|
|
|
2009-12-22 22:23:30 +08:00
|
|
|
/// getTypeSizeInChars - Return the size of the specified type, in characters.
|
|
|
|
/// This method does not work on incomplete types.
|
|
|
|
CharUnits ASTContext::getTypeSizeInChars(QualType T) {
|
2010-01-12 01:06:35 +08:00
|
|
|
return CharUnits::fromQuantity(getTypeSize(T) / getCharWidth());
|
2009-12-22 22:23:30 +08:00
|
|
|
}
|
|
|
|
CharUnits ASTContext::getTypeSizeInChars(const Type *T) {
|
2010-01-12 01:06:35 +08:00
|
|
|
return CharUnits::fromQuantity(getTypeSize(T) / getCharWidth());
|
2009-12-22 22:23:30 +08:00
|
|
|
}
|
|
|
|
|
2010-01-27 01:25:18 +08:00
|
|
|
/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
|
2010-01-27 01:22:55 +08:00
|
|
|
/// characters. This method does not work on incomplete types.
|
|
|
|
CharUnits ASTContext::getTypeAlignInChars(QualType T) {
|
|
|
|
return CharUnits::fromQuantity(getTypeAlign(T) / getCharWidth());
|
|
|
|
}
|
|
|
|
CharUnits ASTContext::getTypeAlignInChars(const Type *T) {
|
|
|
|
return CharUnits::fromQuantity(getTypeAlign(T) / getCharWidth());
|
|
|
|
}
|
|
|
|
|
2009-01-28 02:08:34 +08:00
|
|
|
/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
|
|
|
|
/// type for the current target in bits. This can be different than the ABI
|
|
|
|
/// alignment in cases where it is beneficial for performance to overalign
|
|
|
|
/// a data type.
|
|
|
|
unsigned ASTContext::getPreferredTypeAlign(const Type *T) {
|
|
|
|
unsigned ABIAlign = getTypeAlign(T);
|
2009-05-26 05:27:19 +08:00
|
|
|
|
|
|
|
// Double and long long should be naturally aligned if possible.
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const ComplexType* CT = T->getAs<ComplexType>())
|
2009-05-26 05:27:19 +08:00
|
|
|
T = CT->getElementType().getTypePtr();
|
|
|
|
if (T->isSpecificBuiltinType(BuiltinType::Double) ||
|
|
|
|
T->isSpecificBuiltinType(BuiltinType::LongLong))
|
|
|
|
return std::max(ABIAlign, (unsigned)getTypeSize(T));
|
|
|
|
|
2009-01-28 02:08:34 +08:00
|
|
|
return ABIAlign;
|
|
|
|
}
|
|
|
|
|
2009-06-04 09:19:09 +08:00
|
|
|
/// ShallowCollectObjCIvars -
|
|
|
|
/// Collect all ivars, including those synthesized, in the current class.
|
|
|
|
///
|
|
|
|
void ASTContext::ShallowCollectObjCIvars(const ObjCInterfaceDecl *OI,
|
2010-02-19 08:31:17 +08:00
|
|
|
llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
|
2010-08-21 05:21:08 +08:00
|
|
|
// FIXME. This need be removed but there are two many places which
|
|
|
|
// assume const-ness of ObjCInterfaceDecl
|
|
|
|
ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
|
|
|
|
for (ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
|
|
|
|
Iv= Iv->getNextIvar())
|
|
|
|
Ivars.push_back(Iv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// DeepCollectObjCIvars -
|
|
|
|
/// This routine first collects all declared, but not synthesized, ivars in
|
|
|
|
/// super class and then collects all ivars, including those synthesized for
|
|
|
|
/// current class. This routine is used for implementation of current class
|
|
|
|
/// when all ivars, declared and synthesized are known.
|
2009-05-13 02:14:29 +08:00
|
|
|
///
|
2010-08-21 05:21:08 +08:00
|
|
|
void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
|
|
|
|
bool leafClass,
|
2009-05-13 02:14:29 +08:00
|
|
|
llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
|
2010-08-21 05:21:08 +08:00
|
|
|
if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
|
|
|
|
DeepCollectObjCIvars(SuperClass, false, Ivars);
|
|
|
|
if (!leafClass) {
|
|
|
|
for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
|
|
|
|
E = OI->ivar_end(); I != E; ++I)
|
2010-02-19 08:31:17 +08:00
|
|
|
Ivars.push_back(*I);
|
|
|
|
}
|
2010-08-21 05:21:08 +08:00
|
|
|
else
|
|
|
|
ShallowCollectObjCIvars(OI, Ivars);
|
2009-05-13 02:14:29 +08:00
|
|
|
}
|
|
|
|
|
2009-10-30 09:13:23 +08:00
|
|
|
/// CollectInheritedProtocols - Collect all protocols in current class and
|
|
|
|
/// those inherited by it.
|
|
|
|
void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
|
2010-02-13 03:27:33 +08:00
|
|
|
llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
|
2009-10-30 09:13:23 +08:00
|
|
|
if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
|
2010-09-01 09:21:15 +08:00
|
|
|
// We can use protocol_iterator here instead of
|
|
|
|
// all_referenced_protocol_iterator since we are walking all categories.
|
|
|
|
for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(),
|
|
|
|
PE = OI->all_referenced_protocol_end(); P != PE; ++P) {
|
2009-10-30 09:13:23 +08:00
|
|
|
ObjCProtocolDecl *Proto = (*P);
|
2010-02-13 03:27:33 +08:00
|
|
|
Protocols.insert(Proto);
|
2009-10-30 09:13:23 +08:00
|
|
|
for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
|
2010-02-26 02:24:33 +08:00
|
|
|
PE = Proto->protocol_end(); P != PE; ++P) {
|
|
|
|
Protocols.insert(*P);
|
2009-10-30 09:13:23 +08:00
|
|
|
CollectInheritedProtocols(*P, Protocols);
|
|
|
|
}
|
2010-02-26 02:24:33 +08:00
|
|
|
}
|
2009-10-30 09:13:23 +08:00
|
|
|
|
|
|
|
// Categories of this Interface.
|
|
|
|
for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList();
|
|
|
|
CDeclChain; CDeclChain = CDeclChain->getNextClassCategory())
|
|
|
|
CollectInheritedProtocols(CDeclChain, Protocols);
|
|
|
|
if (ObjCInterfaceDecl *SD = OI->getSuperClass())
|
|
|
|
while (SD) {
|
|
|
|
CollectInheritedProtocols(SD, Protocols);
|
|
|
|
SD = SD->getSuperClass();
|
|
|
|
}
|
2010-04-28 01:47:25 +08:00
|
|
|
} else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
|
2010-09-01 09:21:15 +08:00
|
|
|
for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(),
|
2009-10-30 09:13:23 +08:00
|
|
|
PE = OC->protocol_end(); P != PE; ++P) {
|
|
|
|
ObjCProtocolDecl *Proto = (*P);
|
2010-02-13 03:27:33 +08:00
|
|
|
Protocols.insert(Proto);
|
2009-10-30 09:13:23 +08:00
|
|
|
for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
|
|
|
|
PE = Proto->protocol_end(); P != PE; ++P)
|
|
|
|
CollectInheritedProtocols(*P, Protocols);
|
|
|
|
}
|
2010-04-28 01:47:25 +08:00
|
|
|
} else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
|
2009-10-30 09:13:23 +08:00
|
|
|
for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(),
|
|
|
|
PE = OP->protocol_end(); P != PE; ++P) {
|
|
|
|
ObjCProtocolDecl *Proto = (*P);
|
2010-02-13 03:27:33 +08:00
|
|
|
Protocols.insert(Proto);
|
2009-10-30 09:13:23 +08:00
|
|
|
for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
|
|
|
|
PE = Proto->protocol_end(); P != PE; ++P)
|
|
|
|
CollectInheritedProtocols(*P, Protocols);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-23 02:25:57 +08:00
|
|
|
unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) {
|
|
|
|
unsigned count = 0;
|
|
|
|
// Count ivars declared in class extension.
|
2010-06-23 07:20:40 +08:00
|
|
|
for (const ObjCCategoryDecl *CDecl = OI->getFirstClassExtension(); CDecl;
|
|
|
|
CDecl = CDecl->getNextClassExtension())
|
2010-04-28 01:47:25 +08:00
|
|
|
count += CDecl->ivar_size();
|
|
|
|
|
2010-03-23 02:25:57 +08:00
|
|
|
// Count ivar defined in this class's implementation. This
|
|
|
|
// includes synthesized ivars.
|
|
|
|
if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
|
2010-04-28 01:47:25 +08:00
|
|
|
count += ImplDecl->ivar_size();
|
|
|
|
|
2009-06-04 09:19:09 +08:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2009-07-21 08:05:53 +08:00
|
|
|
/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists.
|
|
|
|
ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
|
|
|
|
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
|
|
|
|
I = ObjCImpls.find(D);
|
|
|
|
if (I != ObjCImpls.end())
|
|
|
|
return cast<ObjCImplementationDecl>(I->second);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists.
|
|
|
|
ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
|
|
|
|
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
|
|
|
|
I = ObjCImpls.find(D);
|
|
|
|
if (I != ObjCImpls.end())
|
|
|
|
return cast<ObjCCategoryImplDecl>(I->second);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Set the implementation of ObjCInterfaceDecl.
|
|
|
|
void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
|
|
|
|
ObjCImplementationDecl *ImplD) {
|
|
|
|
assert(IFaceD && ImplD && "Passed null params");
|
|
|
|
ObjCImpls[IFaceD] = ImplD;
|
|
|
|
}
|
|
|
|
/// \brief Set the implementation of ObjCCategoryDecl.
|
|
|
|
void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
|
|
|
|
ObjCCategoryImplDecl *ImplD) {
|
|
|
|
assert(CatD && ImplD && "Passed null params");
|
|
|
|
ObjCImpls[CatD] = ImplD;
|
|
|
|
}
|
|
|
|
|
2009-12-07 10:54:59 +08:00
|
|
|
/// \brief Allocate an uninitialized TypeSourceInfo.
|
2009-08-19 09:27:32 +08:00
|
|
|
///
|
2009-12-07 10:54:59 +08:00
|
|
|
/// The caller should initialize the memory held by TypeSourceInfo using
|
2009-08-19 09:27:32 +08:00
|
|
|
/// the TypeLoc wrappers.
|
|
|
|
///
|
|
|
|
/// \param T the type that will be the basis for type source info. This type
|
|
|
|
/// should refer to how the declarator was written in source code, not to
|
|
|
|
/// what type semantic analysis resolved the declarator to.
|
2009-12-07 10:54:59 +08:00
|
|
|
TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
|
2009-10-21 08:23:54 +08:00
|
|
|
unsigned DataSize) {
|
|
|
|
if (!DataSize)
|
|
|
|
DataSize = TypeLoc::getFullDataSizeForType(T);
|
|
|
|
else
|
|
|
|
assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&
|
2009-12-07 10:54:59 +08:00
|
|
|
"incorrect data size provided to CreateTypeSourceInfo!");
|
2009-10-21 08:23:54 +08:00
|
|
|
|
2009-12-07 10:54:59 +08:00
|
|
|
TypeSourceInfo *TInfo =
|
|
|
|
(TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
|
|
|
|
new (TInfo) TypeSourceInfo(T);
|
|
|
|
return TInfo;
|
2009-08-19 09:27:32 +08:00
|
|
|
}
|
|
|
|
|
2009-12-07 10:54:59 +08:00
|
|
|
TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
|
2009-10-24 05:14:09 +08:00
|
|
|
SourceLocation L) {
|
2009-12-07 10:54:59 +08:00
|
|
|
TypeSourceInfo *DI = CreateTypeSourceInfo(T);
|
2009-10-24 05:14:09 +08:00
|
|
|
DI->getTypeLoc().initialize(L);
|
|
|
|
return DI;
|
|
|
|
}
|
|
|
|
|
2009-05-03 18:38:35 +08:00
|
|
|
const ASTRecordLayout &
|
|
|
|
ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) {
|
|
|
|
return getObjCLayout(D, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
const ASTRecordLayout &
|
|
|
|
ASTContext::getASTObjCImplementationLayout(const ObjCImplementationDecl *D) {
|
|
|
|
return getObjCLayout(D->getClassInterface(), D);
|
|
|
|
}
|
|
|
|
|
2007-07-14 06:13:22 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Type creation/memoization methods
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
QualType ASTContext::getExtQualType(const Type *TypeNode, Qualifiers Quals) {
|
|
|
|
unsigned Fast = Quals.getFastQualifiers();
|
|
|
|
Quals.removeFastQualifiers();
|
|
|
|
|
|
|
|
// Check if we've already instantiated this type.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
ExtQuals::Profile(ID, TypeNode, Quals);
|
|
|
|
void *InsertPos = 0;
|
|
|
|
if (ExtQuals *EQ = ExtQualNodes.FindNodeOrInsertPos(ID, InsertPos)) {
|
|
|
|
assert(EQ->getQualifiers() == Quals);
|
|
|
|
QualType T = QualType(EQ, Fast);
|
|
|
|
return T;
|
|
|
|
}
|
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
ExtQuals *New = new (*this, TypeAlignment) ExtQuals(*this, TypeNode, Quals);
|
2009-09-25 03:53:00 +08:00
|
|
|
ExtQualNodes.InsertNode(New, InsertPos);
|
|
|
|
QualType T = QualType(New, Fast);
|
|
|
|
return T;
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ASTContext::getVolatileType(QualType T) {
|
|
|
|
QualType CanT = getCanonicalType(T);
|
|
|
|
if (CanT.isVolatileQualified()) return T;
|
|
|
|
|
|
|
|
QualifierCollector Quals;
|
|
|
|
const Type *TypeNode = Quals.strip(T);
|
|
|
|
Quals.addVolatile();
|
|
|
|
|
|
|
|
return getExtQualType(TypeNode, Quals);
|
|
|
|
}
|
|
|
|
|
2009-02-18 02:27:45 +08:00
|
|
|
QualType ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) {
|
2008-04-07 06:59:24 +08:00
|
|
|
QualType CanT = getCanonicalType(T);
|
|
|
|
if (CanT.getAddressSpace() == AddressSpace)
|
2008-02-21 04:55:12 +08:00
|
|
|
return T;
|
2009-02-19 06:53:11 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If we are composing extended qualifiers together, merge together
|
|
|
|
// into one ExtQuals node.
|
|
|
|
QualifierCollector Quals;
|
|
|
|
const Type *TypeNode = Quals.strip(T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If this type already has an address space specified, it cannot get
|
|
|
|
// another one.
|
|
|
|
assert(!Quals.hasAddressSpace() &&
|
|
|
|
"Type cannot be in multiple addr spaces!");
|
|
|
|
Quals.addAddressSpace(AddressSpace);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
return getExtQualType(TypeNode, Quals);
|
2008-02-04 10:31:56 +08:00
|
|
|
}
|
|
|
|
|
2009-02-19 06:53:11 +08:00
|
|
|
QualType ASTContext::getObjCGCQualType(QualType T,
|
2009-09-25 03:53:00 +08:00
|
|
|
Qualifiers::GC GCAttr) {
|
2009-02-18 13:09:49 +08:00
|
|
|
QualType CanT = getCanonicalType(T);
|
2009-02-19 06:53:11 +08:00
|
|
|
if (CanT.getObjCGCAttr() == GCAttr)
|
2009-02-18 13:09:49 +08:00
|
|
|
return T;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-04 01:15:17 +08:00
|
|
|
if (T->isPointerType()) {
|
2009-07-30 05:53:49 +08:00
|
|
|
QualType Pointee = T->getAs<PointerType>()->getPointeeType();
|
2009-07-15 02:25:06 +08:00
|
|
|
if (Pointee->isAnyPointerType()) {
|
2009-06-04 01:15:17 +08:00
|
|
|
QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
|
|
|
|
return getPointerType(ResultType);
|
|
|
|
}
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If we are composing extended qualifiers together, merge together
|
|
|
|
// into one ExtQuals node.
|
|
|
|
QualifierCollector Quals;
|
|
|
|
const Type *TypeNode = Quals.strip(T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If this type already has an ObjCGC specified, it cannot get
|
|
|
|
// another one.
|
|
|
|
assert(!Quals.hasObjCGCAttr() &&
|
|
|
|
"Type cannot have multiple ObjCGCs!");
|
|
|
|
Quals.addObjCGCAttr(GCAttr);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
return getExtQualType(TypeNode, Quals);
|
2009-02-18 13:09:49 +08:00
|
|
|
}
|
2007-07-14 06:13:22 +08:00
|
|
|
|
2010-03-31 04:24:48 +08:00
|
|
|
static QualType getExtFunctionType(ASTContext& Context, QualType T,
|
|
|
|
const FunctionType::ExtInfo &Info) {
|
2009-09-25 03:53:00 +08:00
|
|
|
QualType ResultType;
|
2009-12-09 08:47:37 +08:00
|
|
|
if (const PointerType *Pointer = T->getAs<PointerType>()) {
|
|
|
|
QualType Pointee = Pointer->getPointeeType();
|
2010-03-31 04:24:48 +08:00
|
|
|
ResultType = getExtFunctionType(Context, Pointee, Info);
|
2009-12-09 08:47:37 +08:00
|
|
|
if (ResultType == Pointee)
|
|
|
|
return T;
|
2010-01-19 01:14:39 +08:00
|
|
|
|
|
|
|
ResultType = Context.getPointerType(ResultType);
|
2009-12-09 08:47:37 +08:00
|
|
|
} else if (const BlockPointerType *BlockPointer
|
|
|
|
= T->getAs<BlockPointerType>()) {
|
|
|
|
QualType Pointee = BlockPointer->getPointeeType();
|
2010-03-31 04:24:48 +08:00
|
|
|
ResultType = getExtFunctionType(Context, Pointee, Info);
|
2009-12-09 08:47:37 +08:00
|
|
|
if (ResultType == Pointee)
|
|
|
|
return T;
|
2010-01-19 01:14:39 +08:00
|
|
|
|
|
|
|
ResultType = Context.getBlockPointerType(ResultType);
|
2010-09-02 00:29:03 +08:00
|
|
|
} else if (const MemberPointerType *MemberPointer
|
|
|
|
= T->getAs<MemberPointerType>()) {
|
|
|
|
QualType Pointee = MemberPointer->getPointeeType();
|
|
|
|
ResultType = getExtFunctionType(Context, Pointee, Info);
|
|
|
|
if (ResultType == Pointee)
|
|
|
|
return T;
|
|
|
|
|
|
|
|
ResultType = Context.getMemberPointerType(ResultType,
|
|
|
|
MemberPointer->getClass());
|
2010-01-19 01:14:39 +08:00
|
|
|
} else if (const FunctionType *F = T->getAs<FunctionType>()) {
|
2010-03-31 04:24:48 +08:00
|
|
|
if (F->getExtInfo() == Info)
|
2009-12-09 08:47:37 +08:00
|
|
|
return T;
|
2010-01-19 01:14:39 +08:00
|
|
|
|
2009-12-09 08:47:37 +08:00
|
|
|
if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(F)) {
|
2010-01-19 01:14:39 +08:00
|
|
|
ResultType = Context.getFunctionNoProtoType(FNPT->getResultType(),
|
2010-03-31 04:24:48 +08:00
|
|
|
Info);
|
2009-09-25 03:53:00 +08:00
|
|
|
} else {
|
2009-12-09 08:47:37 +08:00
|
|
|
const FunctionProtoType *FPT = cast<FunctionProtoType>(F);
|
2009-09-25 03:53:00 +08:00
|
|
|
ResultType
|
2010-01-19 01:14:39 +08:00
|
|
|
= Context.getFunctionType(FPT->getResultType(), FPT->arg_type_begin(),
|
|
|
|
FPT->getNumArgs(), FPT->isVariadic(),
|
|
|
|
FPT->getTypeQuals(),
|
|
|
|
FPT->hasExceptionSpec(),
|
|
|
|
FPT->hasAnyExceptionSpec(),
|
|
|
|
FPT->getNumExceptions(),
|
|
|
|
FPT->exception_begin(),
|
2010-03-31 04:24:48 +08:00
|
|
|
Info);
|
2009-09-25 03:53:00 +08:00
|
|
|
}
|
2009-12-09 08:47:37 +08:00
|
|
|
} else
|
|
|
|
return T;
|
2010-01-19 01:14:39 +08:00
|
|
|
|
|
|
|
return Context.getQualifiedType(ResultType, T.getLocalQualifiers());
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ASTContext::getNoReturnType(QualType T, bool AddNoReturn) {
|
2010-03-31 06:15:11 +08:00
|
|
|
FunctionType::ExtInfo Info = getFunctionExtInfo(T);
|
2010-03-31 04:24:48 +08:00
|
|
|
return getExtFunctionType(*this, T,
|
|
|
|
Info.withNoReturn(AddNoReturn));
|
2010-01-19 01:14:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
QualType ASTContext::getCallConvType(QualType T, CallingConv CallConv) {
|
2010-03-31 06:15:11 +08:00
|
|
|
FunctionType::ExtInfo Info = getFunctionExtInfo(T);
|
2010-03-31 04:24:48 +08:00
|
|
|
return getExtFunctionType(*this, T,
|
|
|
|
Info.withCallingConv(CallConv));
|
2009-07-26 05:26:53 +08:00
|
|
|
}
|
|
|
|
|
2010-03-31 06:15:11 +08:00
|
|
|
QualType ASTContext::getRegParmType(QualType T, unsigned RegParm) {
|
|
|
|
FunctionType::ExtInfo Info = getFunctionExtInfo(T);
|
|
|
|
return getExtFunctionType(*this, T,
|
|
|
|
Info.withRegParm(RegParm));
|
|
|
|
}
|
|
|
|
|
2007-06-23 04:56:16 +08:00
|
|
|
/// getComplexType - Return the uniqued reference to the type for a complex
|
|
|
|
/// number with the specified element type.
|
|
|
|
QualType ASTContext::getComplexType(QualType T) {
|
|
|
|
// Unique pointers, to guarantee there is only one pointer of a particular
|
|
|
|
// structure.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
ComplexType::Profile(ID, T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-06-23 04:56:16 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(CT, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-06-23 04:56:16 +08:00
|
|
|
// If the pointee type isn't canonical, this won't be a canonical type either,
|
|
|
|
// so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2009-10-23 04:10:53 +08:00
|
|
|
if (!T.isCanonical()) {
|
2008-04-07 06:59:24 +08:00
|
|
|
Canonical = getComplexType(getCanonicalType(T));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-06-23 04:56:16 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-06-23 04:56:16 +08:00
|
|
|
}
|
2009-09-25 07:30:46 +08:00
|
|
|
ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
|
2007-06-23 04:56:16 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
ComplexTypes.InsertNode(New, InsertPos);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2006-11-12 08:37:36 +08:00
|
|
|
/// getPointerType - Return the uniqued reference to the type for a pointer to
|
|
|
|
/// the specified type.
|
2007-04-06 06:36:20 +08:00
|
|
|
QualType ASTContext::getPointerType(QualType T) {
|
2006-11-12 08:53:46 +08:00
|
|
|
// Unique pointers, to guarantee there is only one pointer of a particular
|
|
|
|
// structure.
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2007-01-27 09:29:36 +08:00
|
|
|
PointerType::Profile(ID, T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-01-27 09:29:36 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(PT, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 16:50:50 +08:00
|
|
|
// If the pointee type isn't canonical, this won't be a canonical type either,
|
|
|
|
// so fill in the canonical type field.
|
2007-04-06 06:36:20 +08:00
|
|
|
QualType Canonical;
|
2009-10-23 04:10:53 +08:00
|
|
|
if (!T.isCanonical()) {
|
2008-04-07 06:59:24 +08:00
|
|
|
Canonical = getPointerType(getCanonicalType(T));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-01-27 09:29:36 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-01-27 09:29:36 +08:00
|
|
|
}
|
2009-09-25 07:30:46 +08:00
|
|
|
PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical);
|
2007-01-27 09:29:36 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
PointerTypes.InsertNode(New, InsertPos);
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(New, 0);
|
2006-11-10 14:34:16 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// getBlockPointerType - Return the uniqued reference to the type for
|
2008-08-28 00:04:49 +08:00
|
|
|
/// a pointer to the specified block.
|
|
|
|
QualType ASTContext::getBlockPointerType(QualType T) {
|
2008-08-29 03:20:44 +08:00
|
|
|
assert(T->isFunctionType() && "block of function types only");
|
|
|
|
// Unique pointers, to guarantee there is only one block of a particular
|
2008-08-28 00:04:49 +08:00
|
|
|
// structure.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
BlockPointerType::Profile(ID, T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-28 00:04:49 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (BlockPointerType *PT =
|
|
|
|
BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(PT, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// If the block pointee type isn't canonical, this won't be a canonical
|
2008-08-28 00:04:49 +08:00
|
|
|
// type either so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2009-10-23 04:10:53 +08:00
|
|
|
if (!T.isCanonical()) {
|
2008-08-28 00:04:49 +08:00
|
|
|
Canonical = getBlockPointerType(getCanonicalType(T));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-28 00:04:49 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
BlockPointerType *NewIP =
|
|
|
|
BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2008-08-28 00:04:49 +08:00
|
|
|
}
|
2009-09-25 07:30:46 +08:00
|
|
|
BlockPointerType *New
|
|
|
|
= new (*this, TypeAlignment) BlockPointerType(T, Canonical);
|
2008-08-28 00:04:49 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
BlockPointerTypes.InsertNode(New, InsertPos);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2009-03-17 07:22:08 +08:00
|
|
|
/// getLValueReferenceType - Return the uniqued reference to the type for an
|
|
|
|
/// lvalue reference to the specified type.
|
2009-10-23 06:37:11 +08:00
|
|
|
QualType ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) {
|
2007-05-27 18:15:43 +08:00
|
|
|
// Unique pointers, to guarantee there is only one pointer of a particular
|
|
|
|
// structure.
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-10-23 06:37:11 +08:00
|
|
|
ReferenceType::Profile(ID, T, SpelledAsLValue);
|
2007-05-27 18:15:43 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
2009-03-17 07:22:08 +08:00
|
|
|
if (LValueReferenceType *RT =
|
|
|
|
LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
|
2007-05-27 18:15:43 +08:00
|
|
|
return QualType(RT, 0);
|
2009-03-17 07:22:08 +08:00
|
|
|
|
2009-10-23 06:37:11 +08:00
|
|
|
const ReferenceType *InnerRef = T->getAs<ReferenceType>();
|
|
|
|
|
2007-05-27 18:15:43 +08:00
|
|
|
// If the referencee type isn't canonical, this won't be a canonical type
|
|
|
|
// either, so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2009-10-23 06:37:11 +08:00
|
|
|
if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
|
|
|
|
QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
|
|
|
|
Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
|
2009-03-17 07:22:08 +08:00
|
|
|
|
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
LValueReferenceType *NewIP =
|
|
|
|
LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
|
|
|
}
|
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
LValueReferenceType *New
|
2009-10-23 06:37:11 +08:00
|
|
|
= new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
|
|
|
|
SpelledAsLValue);
|
2009-03-17 07:22:08 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
LValueReferenceTypes.InsertNode(New, InsertPos);
|
2009-10-23 06:37:11 +08:00
|
|
|
|
2009-03-17 07:22:08 +08:00
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getRValueReferenceType - Return the uniqued reference to the type for an
|
|
|
|
/// rvalue reference to the specified type.
|
|
|
|
QualType ASTContext::getRValueReferenceType(QualType T) {
|
|
|
|
// Unique pointers, to guarantee there is only one pointer of a particular
|
|
|
|
// structure.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-10-23 06:37:11 +08:00
|
|
|
ReferenceType::Profile(ID, T, false);
|
2009-03-17 07:22:08 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
|
|
|
if (RValueReferenceType *RT =
|
|
|
|
RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(RT, 0);
|
|
|
|
|
2009-10-23 06:37:11 +08:00
|
|
|
const ReferenceType *InnerRef = T->getAs<ReferenceType>();
|
|
|
|
|
2009-03-17 07:22:08 +08:00
|
|
|
// If the referencee type isn't canonical, this won't be a canonical type
|
|
|
|
// either, so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2009-10-23 06:37:11 +08:00
|
|
|
if (InnerRef || !T.isCanonical()) {
|
|
|
|
QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
|
|
|
|
Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
|
2009-03-17 07:22:08 +08:00
|
|
|
|
2007-05-27 18:15:43 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
2009-03-17 07:22:08 +08:00
|
|
|
RValueReferenceType *NewIP =
|
|
|
|
RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-05-27 18:15:43 +08:00
|
|
|
}
|
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
RValueReferenceType *New
|
|
|
|
= new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
|
2007-05-27 18:15:43 +08:00
|
|
|
Types.push_back(New);
|
2009-03-17 07:22:08 +08:00
|
|
|
RValueReferenceTypes.InsertNode(New, InsertPos);
|
2007-05-27 18:15:43 +08:00
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2009-01-25 05:16:55 +08:00
|
|
|
/// getMemberPointerType - Return the uniqued reference to the type for a
|
|
|
|
/// member pointer to the specified type, in the specified class.
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) {
|
2009-01-25 05:16:55 +08:00
|
|
|
// Unique pointers, to guarantee there is only one pointer of a particular
|
|
|
|
// structure.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
MemberPointerType::Profile(ID, T, Cls);
|
|
|
|
|
|
|
|
void *InsertPos = 0;
|
|
|
|
if (MemberPointerType *PT =
|
|
|
|
MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(PT, 0);
|
|
|
|
|
|
|
|
// If the pointee or class type isn't canonical, this won't be a canonical
|
|
|
|
// type either, so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2009-11-05 00:49:01 +08:00
|
|
|
if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
|
2009-01-25 05:16:55 +08:00
|
|
|
Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
|
|
|
|
|
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
MemberPointerType *NewIP =
|
|
|
|
MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
|
|
|
}
|
2009-09-25 07:30:46 +08:00
|
|
|
MemberPointerType *New
|
|
|
|
= new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
|
2009-01-25 05:16:55 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
MemberPointerTypes.InsertNode(New, InsertPos);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// getConstantArrayType - Return the unique reference to the type for an
|
2007-08-30 09:06:46 +08:00
|
|
|
/// array of the specified element type.
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType ASTContext::getConstantArrayType(QualType EltTy,
|
2009-05-13 12:12:56 +08:00
|
|
|
const llvm::APInt &ArySizeIn,
|
2007-08-31 02:10:14 +08:00
|
|
|
ArrayType::ArraySizeModifier ASM,
|
|
|
|
unsigned EltTypeQuals) {
|
2009-11-05 23:52:31 +08:00
|
|
|
assert((EltTy->isDependentType() ||
|
|
|
|
EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
|
2009-05-30 04:17:55 +08:00
|
|
|
"Constant array of VLAs is illegal!");
|
|
|
|
|
2009-05-13 12:12:56 +08:00
|
|
|
// Convert the array size into a canonical width matching the pointer size for
|
|
|
|
// the target.
|
|
|
|
llvm::APInt ArySize(ArySizeIn);
|
|
|
|
ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-02-20 01:31:02 +08:00
|
|
|
ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, EltTypeQuals);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-01-27 16:31:04 +08:00
|
|
|
void *InsertPos = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
if (ConstantArrayType *ATP =
|
2007-11-01 01:10:13 +08:00
|
|
|
ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(ATP, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2006-11-12 16:50:50 +08:00
|
|
|
// If the element type isn't canonical, this won't be a canonical type either,
|
|
|
|
// so fill in the canonical type field.
|
2007-04-06 06:36:20 +08:00
|
|
|
QualType Canonical;
|
2009-10-23 04:10:53 +08:00
|
|
|
if (!EltTy.isCanonical()) {
|
2009-09-09 23:08:12 +08:00
|
|
|
Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize,
|
2007-08-31 02:10:14 +08:00
|
|
|
ASM, EltTypeQuals);
|
2007-01-27 16:31:04 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
2009-09-09 23:08:12 +08:00
|
|
|
ConstantArrayType *NewIP =
|
2007-11-01 01:10:13 +08:00
|
|
|
ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-01-27 16:31:04 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
ConstantArrayType *New = new(*this,TypeAlignment)
|
|
|
|
ConstantArrayType(EltTy, Canonical, ArySize, ASM, EltTypeQuals);
|
2007-11-01 01:10:13 +08:00
|
|
|
ConstantArrayTypes.InsertNode(New, InsertPos);
|
2007-01-27 16:31:04 +08:00
|
|
|
Types.push_back(New);
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(New, 0);
|
2006-11-12 16:50:50 +08:00
|
|
|
}
|
|
|
|
|
2010-09-25 01:30:16 +08:00
|
|
|
/// getIncompleteArrayType - Returns a unique reference to the type for a
|
|
|
|
/// incomplete array of the specified element type.
|
|
|
|
QualType ASTContext::getUnknownSizeVariableArrayType(QualType Ty) {
|
|
|
|
QualType ElemTy = getBaseElementType(Ty);
|
|
|
|
DeclarationName Name;
|
|
|
|
llvm::SmallVector<QualType, 8> ATypes;
|
|
|
|
QualType ATy = Ty;
|
|
|
|
while (const ArrayType *AT = getAsArrayType(ATy)) {
|
|
|
|
ATypes.push_back(ATy);
|
|
|
|
ATy = AT->getElementType();
|
|
|
|
}
|
|
|
|
for (int i = ATypes.size() - 1; i >= 0; i--) {
|
|
|
|
if (const VariableArrayType *VAT = getAsVariableArrayType(ATypes[i])) {
|
|
|
|
ElemTy = getVariableArrayType(ElemTy, /*ArraySize*/0, ArrayType::Star,
|
|
|
|
0, VAT->getBracketsRange());
|
|
|
|
}
|
|
|
|
else if (const ConstantArrayType *CAT = getAsConstantArrayType(ATypes[i])) {
|
|
|
|
llvm::APSInt ConstVal(CAT->getSize());
|
|
|
|
ElemTy = getConstantArrayType(ElemTy, ConstVal, ArrayType::Normal, 0);
|
|
|
|
}
|
|
|
|
else if (getAsIncompleteArrayType(ATypes[i])) {
|
|
|
|
ElemTy = getVariableArrayType(ElemTy, /*ArraySize*/0, ArrayType::Normal,
|
|
|
|
0, SourceRange());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
assert(false && "DependentArrayType is seen");
|
|
|
|
}
|
|
|
|
return ElemTy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getVariableArrayDecayedType - Returns a vla type where known sizes
|
|
|
|
/// are replaced with [*]
|
|
|
|
QualType ASTContext::getVariableArrayDecayedType(QualType Ty) {
|
|
|
|
if (Ty->isPointerType()) {
|
|
|
|
QualType BaseType = Ty->getAs<PointerType>()->getPointeeType();
|
|
|
|
if (isa<VariableArrayType>(BaseType)) {
|
|
|
|
ArrayType *AT = dyn_cast<ArrayType>(BaseType);
|
|
|
|
VariableArrayType *VAT = cast<VariableArrayType>(AT);
|
|
|
|
if (VAT->getSizeExpr()) {
|
|
|
|
Ty = getUnknownSizeVariableArrayType(BaseType);
|
|
|
|
Ty = getPointerType(Ty);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Ty;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-31 02:14:25 +08:00
|
|
|
/// getVariableArrayType - Returns a non-unique reference to the type for a
|
|
|
|
/// variable array of the specified element type.
|
2009-07-06 23:59:29 +08:00
|
|
|
QualType ASTContext::getVariableArrayType(QualType EltTy,
|
|
|
|
Expr *NumElts,
|
2007-08-31 02:10:14 +08:00
|
|
|
ArrayType::ArraySizeModifier ASM,
|
2009-07-06 23:59:29 +08:00
|
|
|
unsigned EltTypeQuals,
|
|
|
|
SourceRange Brackets) {
|
2008-02-16 02:16:39 +08:00
|
|
|
// Since we don't unique expressions, it isn't possible to unique VLA's
|
|
|
|
// that have an expression provided for their size.
|
2010-05-24 00:10:32 +08:00
|
|
|
QualType CanonType;
|
|
|
|
|
|
|
|
if (!EltTy.isCanonical()) {
|
|
|
|
if (NumElts)
|
|
|
|
NumElts->Retain();
|
|
|
|
CanonType = getVariableArrayType(getCanonicalType(EltTy), NumElts, ASM,
|
|
|
|
EltTypeQuals, Brackets);
|
|
|
|
}
|
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
VariableArrayType *New = new(*this, TypeAlignment)
|
2010-05-24 00:10:32 +08:00
|
|
|
VariableArrayType(EltTy, CanonType, NumElts, ASM, EltTypeQuals, Brackets);
|
2008-02-16 02:16:39 +08:00
|
|
|
|
|
|
|
VariableArrayTypes.push_back(New);
|
|
|
|
Types.push_back(New);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2008-12-06 07:32:09 +08:00
|
|
|
/// getDependentSizedArrayType - Returns a non-unique reference to
|
|
|
|
/// the type for a dependently-sized array of the specified element
|
2009-07-31 08:23:35 +08:00
|
|
|
/// type.
|
2009-07-06 23:59:29 +08:00
|
|
|
QualType ASTContext::getDependentSizedArrayType(QualType EltTy,
|
|
|
|
Expr *NumElts,
|
2008-12-06 07:32:09 +08:00
|
|
|
ArrayType::ArraySizeModifier ASM,
|
2009-07-06 23:59:29 +08:00
|
|
|
unsigned EltTypeQuals,
|
|
|
|
SourceRange Brackets) {
|
2009-11-20 02:03:26 +08:00
|
|
|
assert((!NumElts || NumElts->isTypeDependent() ||
|
|
|
|
NumElts->isValueDependent()) &&
|
2008-12-06 07:32:09 +08:00
|
|
|
"Size must be type- or value-dependent!");
|
|
|
|
|
2009-07-31 08:23:35 +08:00
|
|
|
void *InsertPos = 0;
|
2009-11-20 02:03:26 +08:00
|
|
|
DependentSizedArrayType *Canon = 0;
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-11-20 02:03:26 +08:00
|
|
|
|
2010-10-26 08:51:02 +08:00
|
|
|
QualType CanonicalEltTy = getCanonicalType(EltTy);
|
2009-11-20 02:03:26 +08:00
|
|
|
if (NumElts) {
|
|
|
|
// Dependently-sized array types that do not have a specified
|
|
|
|
// number of elements will have their sizes deduced from an
|
|
|
|
// initializer.
|
2010-10-26 08:51:02 +08:00
|
|
|
DependentSizedArrayType::Profile(ID, *this, CanonicalEltTy, ASM,
|
2009-11-20 02:03:26 +08:00
|
|
|
EltTypeQuals, NumElts);
|
|
|
|
|
|
|
|
Canon = DependentSizedArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
}
|
|
|
|
|
2009-07-31 08:23:35 +08:00
|
|
|
DependentSizedArrayType *New;
|
|
|
|
if (Canon) {
|
|
|
|
// We already have a canonical version of this array type; use it as
|
|
|
|
// the canonical type for a newly-built type.
|
2009-09-25 07:30:46 +08:00
|
|
|
New = new (*this, TypeAlignment)
|
|
|
|
DependentSizedArrayType(*this, EltTy, QualType(Canon, 0),
|
|
|
|
NumElts, ASM, EltTypeQuals, Brackets);
|
2010-10-26 08:51:02 +08:00
|
|
|
} else if (CanonicalEltTy == EltTy) {
|
|
|
|
// This is a canonical type. Record it.
|
|
|
|
New = new (*this, TypeAlignment)
|
|
|
|
DependentSizedArrayType(*this, EltTy, QualType(),
|
|
|
|
NumElts, ASM, EltTypeQuals, Brackets);
|
|
|
|
|
|
|
|
if (NumElts) {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
DependentSizedArrayType *CanonCheck
|
|
|
|
= DependentSizedArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(!CanonCheck && "Dependent-sized canonical array type broken");
|
|
|
|
(void)CanonCheck;
|
|
|
|
#endif
|
|
|
|
DependentSizedArrayTypes.InsertNode(New, InsertPos);
|
2009-07-31 08:23:35 +08:00
|
|
|
}
|
2010-10-26 08:51:02 +08:00
|
|
|
} else {
|
|
|
|
QualType Canon = getDependentSizedArrayType(CanonicalEltTy, NumElts,
|
|
|
|
ASM, EltTypeQuals,
|
|
|
|
SourceRange());
|
|
|
|
New = new (*this, TypeAlignment)
|
|
|
|
DependentSizedArrayType(*this, EltTy, Canon,
|
|
|
|
NumElts, ASM, EltTypeQuals, Brackets);
|
2009-07-31 08:23:35 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-12-06 07:32:09 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2008-02-16 02:16:39 +08:00
|
|
|
QualType ASTContext::getIncompleteArrayType(QualType EltTy,
|
|
|
|
ArrayType::ArraySizeModifier ASM,
|
|
|
|
unsigned EltTypeQuals) {
|
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-02-20 01:31:02 +08:00
|
|
|
IncompleteArrayType::Profile(ID, EltTy, ASM, EltTypeQuals);
|
2008-02-16 02:16:39 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
if (IncompleteArrayType *ATP =
|
2008-02-16 02:16:39 +08:00
|
|
|
IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(ATP, 0);
|
|
|
|
|
|
|
|
// If the element type isn't canonical, this won't be a canonical type
|
|
|
|
// either, so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
|
|
|
|
2009-10-23 04:10:53 +08:00
|
|
|
if (!EltTy.isCanonical()) {
|
2008-04-07 06:59:24 +08:00
|
|
|
Canonical = getIncompleteArrayType(getCanonicalType(EltTy),
|
2007-10-30 07:37:31 +08:00
|
|
|
ASM, EltTypeQuals);
|
2008-02-16 02:16:39 +08:00
|
|
|
|
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
IncompleteArrayType *NewIP =
|
|
|
|
IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-10-30 07:37:31 +08:00
|
|
|
}
|
2008-02-16 02:16:39 +08:00
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
IncompleteArrayType *New = new (*this, TypeAlignment)
|
|
|
|
IncompleteArrayType(EltTy, Canonical, ASM, EltTypeQuals);
|
2008-02-16 02:16:39 +08:00
|
|
|
|
|
|
|
IncompleteArrayTypes.InsertNode(New, InsertPos);
|
|
|
|
Types.push_back(New);
|
|
|
|
return QualType(New, 0);
|
2007-08-30 09:06:46 +08:00
|
|
|
}
|
|
|
|
|
2007-07-19 02:00:27 +08:00
|
|
|
/// getVectorType - Return the unique reference to a vector type of
|
|
|
|
/// the specified element type and size. VectorType must be a built-in type.
|
2010-02-05 08:12:22 +08:00
|
|
|
QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
|
2010-10-02 06:42:38 +08:00
|
|
|
VectorType::AltiVecSpecific AltiVecSpec) {
|
|
|
|
BuiltinType *BaseType;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-10-02 06:42:38 +08:00
|
|
|
BaseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr());
|
|
|
|
assert(BaseType != 0 && "getVectorType(): Expecting a built-in type");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-07-07 07:09:18 +08:00
|
|
|
// Check if we've already instantiated a vector of this type.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-06-23 14:00:24 +08:00
|
|
|
VectorType::Profile(ID, vecType, NumElts, Type::Vector, AltiVecSpec);
|
|
|
|
|
2007-07-07 07:09:18 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(VTP, 0);
|
|
|
|
|
|
|
|
// If the element type isn't canonical, this won't be a canonical type either,
|
|
|
|
// so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2010-08-06 18:14:59 +08:00
|
|
|
if (!vecType.isCanonical()) {
|
2010-06-23 14:00:24 +08:00
|
|
|
Canonical = getVectorType(getCanonicalType(vecType), NumElts,
|
|
|
|
VectorType::NotAltiVec);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-07-07 07:09:18 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-07-07 07:09:18 +08:00
|
|
|
}
|
2009-09-25 07:30:46 +08:00
|
|
|
VectorType *New = new (*this, TypeAlignment)
|
2010-06-23 14:00:24 +08:00
|
|
|
VectorType(vecType, NumElts, Canonical, AltiVecSpec);
|
2007-07-07 07:09:18 +08:00
|
|
|
VectorTypes.InsertNode(New, InsertPos);
|
|
|
|
Types.push_back(New);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2008-04-19 07:10:10 +08:00
|
|
|
/// getExtVectorType - Return the unique reference to an extended vector type of
|
2007-07-19 02:00:27 +08:00
|
|
|
/// the specified element type and size. VectorType must be a built-in type.
|
2008-04-19 07:10:10 +08:00
|
|
|
QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) {
|
2007-07-19 02:00:27 +08:00
|
|
|
BuiltinType *baseType;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 06:59:24 +08:00
|
|
|
baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr());
|
2008-04-19 07:10:10 +08:00
|
|
|
assert(baseType != 0 && "getExtVectorType(): Expecting a built-in type");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-07-19 02:00:27 +08:00
|
|
|
// Check if we've already instantiated a vector of this type.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-06-23 14:00:24 +08:00
|
|
|
VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
|
|
|
|
VectorType::NotAltiVec);
|
2007-07-19 02:00:27 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(VTP, 0);
|
|
|
|
|
|
|
|
// If the element type isn't canonical, this won't be a canonical type either,
|
|
|
|
// so fill in the canonical type field.
|
|
|
|
QualType Canonical;
|
2009-10-23 04:10:53 +08:00
|
|
|
if (!vecType.isCanonical()) {
|
2008-04-19 07:10:10 +08:00
|
|
|
Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-07-19 02:00:27 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
|
|
|
VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-07-19 02:00:27 +08:00
|
|
|
}
|
2009-09-25 07:30:46 +08:00
|
|
|
ExtVectorType *New = new (*this, TypeAlignment)
|
|
|
|
ExtVectorType(vecType, NumElts, Canonical);
|
2007-07-19 02:00:27 +08:00
|
|
|
VectorTypes.InsertNode(New, InsertPos);
|
|
|
|
Types.push_back(New);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType ASTContext::getDependentSizedExtVectorType(QualType vecType,
|
2009-06-18 05:51:59 +08:00
|
|
|
Expr *SizeExpr,
|
|
|
|
SourceLocation AttrLoc) {
|
2009-07-31 11:54:25 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-09-09 23:08:12 +08:00
|
|
|
DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
|
2009-07-31 11:54:25 +08:00
|
|
|
SizeExpr);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-31 11:54:25 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
DependentSizedExtVectorType *Canon
|
|
|
|
= DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
DependentSizedExtVectorType *New;
|
|
|
|
if (Canon) {
|
|
|
|
// We already have a canonical version of this array type; use it as
|
|
|
|
// the canonical type for a newly-built type.
|
2009-09-25 07:30:46 +08:00
|
|
|
New = new (*this, TypeAlignment)
|
|
|
|
DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
|
|
|
|
SizeExpr, AttrLoc);
|
2009-07-31 11:54:25 +08:00
|
|
|
} else {
|
|
|
|
QualType CanonVecTy = getCanonicalType(vecType);
|
|
|
|
if (CanonVecTy == vecType) {
|
2009-09-25 07:30:46 +08:00
|
|
|
New = new (*this, TypeAlignment)
|
|
|
|
DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
|
|
|
|
AttrLoc);
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
|
|
|
|
DependentSizedExtVectorType *CanonCheck
|
|
|
|
= DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
|
|
|
|
(void)CanonCheck;
|
2009-07-31 11:54:25 +08:00
|
|
|
DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
|
|
|
|
} else {
|
|
|
|
QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
|
|
|
|
SourceLocation());
|
2009-09-25 07:30:46 +08:00
|
|
|
New = new (*this, TypeAlignment)
|
|
|
|
DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
|
2009-07-31 11:54:25 +08:00
|
|
|
}
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-18 05:51:59 +08:00
|
|
|
Types.push_back(New);
|
|
|
|
return QualType(New, 0);
|
|
|
|
}
|
|
|
|
|
2009-02-27 07:50:07 +08:00
|
|
|
/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
|
2006-12-02 15:52:18 +08:00
|
|
|
///
|
2010-03-31 04:24:48 +08:00
|
|
|
QualType ASTContext::getFunctionNoProtoType(QualType ResultTy,
|
|
|
|
const FunctionType::ExtInfo &Info) {
|
|
|
|
const CallingConv CallConv = Info.getCC();
|
2006-12-02 15:52:18 +08:00
|
|
|
// Unique functions, to guarantee there is only one function of a particular
|
|
|
|
// structure.
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-03-31 04:24:48 +08:00
|
|
|
FunctionNoProtoType::Profile(ID, ResultTy, Info);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-01-27 16:37:20 +08:00
|
|
|
void *InsertPos = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
if (FunctionNoProtoType *FT =
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(FT, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-04-06 06:36:20 +08:00
|
|
|
QualType Canonical;
|
2010-01-19 01:14:39 +08:00
|
|
|
if (!ResultTy.isCanonical() ||
|
2010-02-06 05:31:56 +08:00
|
|
|
getCanonicalCallConv(CallConv) != CallConv) {
|
2010-03-31 04:24:48 +08:00
|
|
|
Canonical =
|
|
|
|
getFunctionNoProtoType(getCanonicalType(ResultTy),
|
|
|
|
Info.withCallingConv(getCanonicalCallConv(CallConv)));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-01-27 16:37:20 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionNoProtoType *NewIP =
|
|
|
|
FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2007-01-27 16:37:20 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 07:30:46 +08:00
|
|
|
FunctionNoProtoType *New = new (*this, TypeAlignment)
|
2010-03-31 04:24:48 +08:00
|
|
|
FunctionNoProtoType(ResultTy, Canonical, Info);
|
2007-01-27 16:37:20 +08:00
|
|
|
Types.push_back(New);
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionNoProtoTypes.InsertNode(New, InsertPos);
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(New, 0);
|
2006-12-02 15:52:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getFunctionType - Return a normal function type with a typed argument
|
|
|
|
/// list. isVariadic indicates whether the argument list includes '...'.
|
2008-10-06 01:34:18 +08:00
|
|
|
QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray,
|
2008-10-25 05:46:40 +08:00
|
|
|
unsigned NumArgs, bool isVariadic,
|
2009-05-28 06:11:52 +08:00
|
|
|
unsigned TypeQuals, bool hasExceptionSpec,
|
|
|
|
bool hasAnyExceptionSpec, unsigned NumExs,
|
2010-03-31 04:24:48 +08:00
|
|
|
const QualType *ExArray,
|
|
|
|
const FunctionType::ExtInfo &Info) {
|
2010-10-02 02:44:50 +08:00
|
|
|
|
2010-03-31 04:24:48 +08:00
|
|
|
const CallingConv CallConv= Info.getCC();
|
2006-12-02 15:52:18 +08:00
|
|
|
// Unique functions, to guarantee there is only one function of a particular
|
|
|
|
// structure.
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
|
2009-05-28 06:11:52 +08:00
|
|
|
TypeQuals, hasExceptionSpec, hasAnyExceptionSpec,
|
2010-03-31 04:24:48 +08:00
|
|
|
NumExs, ExArray, Info);
|
2007-01-27 09:15:32 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
if (FunctionProtoType *FTP =
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(FTP, 0);
|
2009-05-28 06:11:52 +08:00
|
|
|
|
|
|
|
// Determine whether the type being created is already canonical or not.
|
2009-10-23 06:37:11 +08:00
|
|
|
bool isCanonical = !hasExceptionSpec && ResultTy.isCanonical();
|
2006-12-02 15:52:18 +08:00
|
|
|
for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
|
2009-10-23 06:37:11 +08:00
|
|
|
if (!ArgArray[i].isCanonicalAsParam())
|
2006-12-02 15:52:18 +08:00
|
|
|
isCanonical = false;
|
|
|
|
|
|
|
|
// If this type isn't canonical, get the canonical version of it.
|
2009-05-28 06:11:52 +08:00
|
|
|
// The exception spec is not part of the canonical type.
|
2007-04-06 06:36:20 +08:00
|
|
|
QualType Canonical;
|
2010-02-06 05:31:56 +08:00
|
|
|
if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) {
|
2007-06-16 07:05:46 +08:00
|
|
|
llvm::SmallVector<QualType, 16> CanonicalArgs;
|
2006-12-02 15:52:18 +08:00
|
|
|
CanonicalArgs.reserve(NumArgs);
|
|
|
|
for (unsigned i = 0; i != NumArgs; ++i)
|
2009-10-23 06:37:11 +08:00
|
|
|
CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
|
2009-05-28 06:11:52 +08:00
|
|
|
|
2008-04-07 06:59:24 +08:00
|
|
|
Canonical = getFunctionType(getCanonicalType(ResultTy),
|
2009-05-21 17:52:38 +08:00
|
|
|
CanonicalArgs.data(), NumArgs,
|
2009-08-06 03:03:35 +08:00
|
|
|
isVariadic, TypeQuals, false,
|
2010-03-31 04:24:48 +08:00
|
|
|
false, 0, 0,
|
|
|
|
Info.withCallingConv(getCanonicalCallConv(CallConv)));
|
2009-05-28 06:11:52 +08:00
|
|
|
|
2007-01-27 09:15:32 +08:00
|
|
|
// Get the new insert position for the node we care about.
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionProtoType *NewIP =
|
|
|
|
FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2008-10-12 08:26:57 +08:00
|
|
|
assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
|
2006-12-02 15:52:18 +08:00
|
|
|
}
|
2009-05-28 06:11:52 +08:00
|
|
|
|
2009-02-27 07:50:07 +08:00
|
|
|
// FunctionProtoType objects are allocated with extra bytes after them
|
2009-05-28 06:11:52 +08:00
|
|
|
// for two variable size arrays (for parameter and exception types) at the
|
|
|
|
// end of them.
|
2009-09-09 23:08:12 +08:00
|
|
|
FunctionProtoType *FTP =
|
2009-05-28 06:11:52 +08:00
|
|
|
(FunctionProtoType*)Allocate(sizeof(FunctionProtoType) +
|
|
|
|
NumArgs*sizeof(QualType) +
|
2009-09-25 07:30:46 +08:00
|
|
|
NumExs*sizeof(QualType), TypeAlignment);
|
2009-02-27 07:50:07 +08:00
|
|
|
new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic,
|
2009-05-28 06:11:52 +08:00
|
|
|
TypeQuals, hasExceptionSpec, hasAnyExceptionSpec,
|
2010-03-31 04:24:48 +08:00
|
|
|
ExArray, NumExs, Canonical, Info);
|
2006-12-02 15:52:18 +08:00
|
|
|
Types.push_back(FTP);
|
2009-02-27 07:50:07 +08:00
|
|
|
FunctionProtoTypes.InsertNode(FTP, InsertPos);
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(FTP, 0);
|
2006-12-02 15:52:18 +08:00
|
|
|
}
|
2006-11-10 15:17:23 +08:00
|
|
|
|
2010-03-10 11:28:59 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
static bool NeedsInjectedClassNameType(const RecordDecl *D) {
|
|
|
|
if (!isa<CXXRecordDecl>(D)) return false;
|
|
|
|
const CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
|
|
|
|
if (isa<ClassTemplatePartialSpecializationDecl>(RD))
|
|
|
|
return true;
|
|
|
|
if (RD->getDescribedClassTemplate() &&
|
|
|
|
!isa<ClassTemplateSpecializationDecl>(RD))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/// getInjectedClassNameType - Return the unique reference to the
|
|
|
|
/// injected class name type for the specified templated declaration.
|
|
|
|
QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl,
|
|
|
|
QualType TST) {
|
|
|
|
assert(NeedsInjectedClassNameType(Decl));
|
|
|
|
if (Decl->TypeForDecl) {
|
|
|
|
assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
|
2010-07-02 19:55:32 +08:00
|
|
|
} else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDeclaration()) {
|
2010-03-10 11:28:59 +08:00
|
|
|
assert(PrevDecl->TypeForDecl && "previous declaration has no type");
|
|
|
|
Decl->TypeForDecl = PrevDecl->TypeForDecl;
|
|
|
|
assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
|
|
|
|
} else {
|
2010-04-27 08:57:59 +08:00
|
|
|
Decl->TypeForDecl =
|
|
|
|
new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
|
2010-03-10 11:28:59 +08:00
|
|
|
Types.push_back(Decl->TypeForDecl);
|
|
|
|
}
|
|
|
|
return QualType(Decl->TypeForDecl, 0);
|
|
|
|
}
|
|
|
|
|
2008-04-14 05:07:44 +08:00
|
|
|
/// getTypeDeclType - Return the unique reference to the type for the
|
|
|
|
/// specified type declaration.
|
2010-03-10 14:48:02 +08:00
|
|
|
QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) {
|
2008-10-17 00:50:47 +08:00
|
|
|
assert(Decl && "Passed null for Decl param");
|
2010-03-10 14:48:02 +08:00
|
|
|
assert(!Decl->TypeForDecl && "TypeForDecl present in slow case");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-02-16 11:57:14 +08:00
|
|
|
if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(Decl))
|
2008-04-14 05:07:44 +08:00
|
|
|
return getTypedefType(Typedef);
|
2010-03-10 14:48:02 +08:00
|
|
|
|
|
|
|
assert(!isa<TemplateTypeParmDecl>(Decl) &&
|
|
|
|
"Template type parameter types are always available.");
|
|
|
|
|
2010-02-16 11:57:14 +08:00
|
|
|
if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
|
2010-03-10 14:48:02 +08:00
|
|
|
assert(!Record->getPreviousDeclaration() &&
|
|
|
|
"struct/union has previous declaration");
|
|
|
|
assert(!NeedsInjectedClassNameType(Record));
|
2010-07-05 05:44:47 +08:00
|
|
|
return getRecordType(Record);
|
2010-02-16 11:57:14 +08:00
|
|
|
} else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) {
|
2010-03-10 14:48:02 +08:00
|
|
|
assert(!Enum->getPreviousDeclaration() &&
|
|
|
|
"enum has previous declaration");
|
2010-07-05 05:44:47 +08:00
|
|
|
return getEnumType(Enum);
|
2010-02-16 11:57:14 +08:00
|
|
|
} else if (const UnresolvedUsingTypenameDecl *Using =
|
2009-12-05 06:46:56 +08:00
|
|
|
dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
|
|
|
|
Decl->TypeForDecl = new (*this, TypeAlignment) UnresolvedUsingType(Using);
|
2009-07-31 10:02:20 +08:00
|
|
|
} else
|
2010-03-10 14:48:02 +08:00
|
|
|
llvm_unreachable("TypeDecl without a type?");
|
2008-08-08 04:55:28 +08:00
|
|
|
|
2010-03-10 14:48:02 +08:00
|
|
|
Types.push_back(Decl->TypeForDecl);
|
2008-08-08 04:55:28 +08:00
|
|
|
return QualType(Decl->TypeForDecl, 0);
|
2008-04-14 05:07:44 +08:00
|
|
|
}
|
|
|
|
|
2007-01-26 10:01:53 +08:00
|
|
|
/// getTypedefType - Return the unique reference to the type for the
|
2006-11-20 12:02:15 +08:00
|
|
|
/// specified typename decl.
|
2010-07-02 19:55:11 +08:00
|
|
|
QualType
|
|
|
|
ASTContext::getTypedefType(const TypedefDecl *Decl, QualType Canonical) {
|
2007-04-06 06:36:20 +08:00
|
|
|
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-07-02 19:55:11 +08:00
|
|
|
if (Canonical.isNull())
|
|
|
|
Canonical = getCanonicalType(Decl->getUnderlyingType());
|
2009-09-25 07:30:46 +08:00
|
|
|
Decl->TypeForDecl = new(*this, TypeAlignment)
|
|
|
|
TypedefType(Type::Typedef, Decl, Canonical);
|
2007-03-27 04:16:44 +08:00
|
|
|
Types.push_back(Decl->TypeForDecl);
|
2007-04-06 06:36:20 +08:00
|
|
|
return QualType(Decl->TypeForDecl, 0);
|
2006-11-20 12:02:15 +08:00
|
|
|
}
|
|
|
|
|
2010-07-05 05:44:47 +08:00
|
|
|
QualType ASTContext::getRecordType(const RecordDecl *Decl) {
|
|
|
|
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
|
|
|
|
|
|
|
|
if (const RecordDecl *PrevDecl = Decl->getPreviousDeclaration())
|
|
|
|
if (PrevDecl->TypeForDecl)
|
|
|
|
return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
|
|
|
|
|
|
|
|
Decl->TypeForDecl = new (*this, TypeAlignment) RecordType(Decl);
|
|
|
|
Types.push_back(Decl->TypeForDecl);
|
|
|
|
return QualType(Decl->TypeForDecl, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ASTContext::getEnumType(const EnumDecl *Decl) {
|
|
|
|
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
|
|
|
|
|
|
|
|
if (const EnumDecl *PrevDecl = Decl->getPreviousDeclaration())
|
|
|
|
if (PrevDecl->TypeForDecl)
|
|
|
|
return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
|
|
|
|
|
|
|
|
Decl->TypeForDecl = new (*this, TypeAlignment) EnumType(Decl);
|
|
|
|
Types.push_back(Decl->TypeForDecl);
|
|
|
|
return QualType(Decl->TypeForDecl, 0);
|
|
|
|
}
|
|
|
|
|
2009-10-18 17:09:24 +08:00
|
|
|
/// \brief Retrieve a substitution-result type.
|
|
|
|
QualType
|
|
|
|
ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
|
|
|
|
QualType Replacement) {
|
2009-10-23 04:10:53 +08:00
|
|
|
assert(Replacement.isCanonical()
|
2009-10-18 17:09:24 +08:00
|
|
|
&& "replacement types must always be canonical");
|
|
|
|
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
|
|
|
|
void *InsertPos = 0;
|
|
|
|
SubstTemplateTypeParmType *SubstParm
|
|
|
|
= SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
|
|
|
|
if (!SubstParm) {
|
|
|
|
SubstParm = new (*this, TypeAlignment)
|
|
|
|
SubstTemplateTypeParmType(Parm, Replacement);
|
|
|
|
Types.push_back(SubstParm);
|
|
|
|
SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
return QualType(SubstParm, 0);
|
|
|
|
}
|
|
|
|
|
2009-02-06 07:33:38 +08:00
|
|
|
/// \brief Retrieve the template type parameter type for a template
|
2009-09-09 23:08:12 +08:00
|
|
|
/// parameter or parameter pack with the given depth, index, and (optionally)
|
2009-06-16 08:30:48 +08:00
|
|
|
/// name.
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
|
2009-06-16 08:30:48 +08:00
|
|
|
bool ParameterPack,
|
2010-06-16 23:23:05 +08:00
|
|
|
IdentifierInfo *Name) {
|
2009-02-06 07:33:38 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-06-16 23:23:05 +08:00
|
|
|
TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, Name);
|
2009-02-06 07:33:38 +08:00
|
|
|
void *InsertPos = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateTypeParmType *TypeParm
|
2009-02-06 07:33:38 +08:00
|
|
|
= TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
|
|
|
|
if (TypeParm)
|
|
|
|
return QualType(TypeParm, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-06-16 23:23:05 +08:00
|
|
|
if (Name) {
|
2009-06-16 08:30:48 +08:00
|
|
|
QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
|
2010-06-16 23:23:05 +08:00
|
|
|
TypeParm = new (*this, TypeAlignment)
|
|
|
|
TemplateTypeParmType(Depth, Index, ParameterPack, Name, Canon);
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
|
|
|
|
TemplateTypeParmType *TypeCheck
|
|
|
|
= TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(!TypeCheck && "Template type parameter canonical type broken");
|
|
|
|
(void)TypeCheck;
|
2009-06-16 08:30:48 +08:00
|
|
|
} else
|
2009-09-25 07:30:46 +08:00
|
|
|
TypeParm = new (*this, TypeAlignment)
|
|
|
|
TemplateTypeParmType(Depth, Index, ParameterPack);
|
2009-02-06 07:33:38 +08:00
|
|
|
|
|
|
|
Types.push_back(TypeParm);
|
|
|
|
TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
|
|
|
|
|
|
|
|
return QualType(TypeParm, 0);
|
|
|
|
}
|
|
|
|
|
2010-03-10 11:28:59 +08:00
|
|
|
TypeSourceInfo *
|
|
|
|
ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
|
|
|
|
SourceLocation NameLoc,
|
|
|
|
const TemplateArgumentListInfo &Args,
|
|
|
|
QualType CanonType) {
|
|
|
|
QualType TST = getTemplateSpecializationType(Name, Args, CanonType);
|
|
|
|
|
|
|
|
TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
|
|
|
|
TemplateSpecializationTypeLoc TL
|
|
|
|
= cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc());
|
|
|
|
TL.setTemplateNameLoc(NameLoc);
|
|
|
|
TL.setLAngleLoc(Args.getLAngleLoc());
|
|
|
|
TL.setRAngleLoc(Args.getRAngleLoc());
|
|
|
|
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
|
|
|
|
TL.setArgLocInfo(i, Args[i].getLocInfo());
|
|
|
|
return DI;
|
|
|
|
}
|
|
|
|
|
2009-10-29 16:12:44 +08:00
|
|
|
QualType
|
|
|
|
ASTContext::getTemplateSpecializationType(TemplateName Template,
|
2009-11-23 09:53:49 +08:00
|
|
|
const TemplateArgumentListInfo &Args,
|
2010-06-13 17:25:03 +08:00
|
|
|
QualType Canon) {
|
2009-11-23 09:53:49 +08:00
|
|
|
unsigned NumArgs = Args.size();
|
|
|
|
|
2009-10-29 16:12:44 +08:00
|
|
|
llvm::SmallVector<TemplateArgument, 4> ArgVec;
|
|
|
|
ArgVec.reserve(NumArgs);
|
|
|
|
for (unsigned i = 0; i != NumArgs; ++i)
|
|
|
|
ArgVec.push_back(Args[i].getArgument());
|
|
|
|
|
2010-04-27 08:57:59 +08:00
|
|
|
return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs,
|
2010-06-13 17:25:03 +08:00
|
|
|
Canon);
|
2009-10-29 16:12:44 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType
|
2009-03-31 06:58:21 +08:00
|
|
|
ASTContext::getTemplateSpecializationType(TemplateName Template,
|
|
|
|
const TemplateArgument *Args,
|
|
|
|
unsigned NumArgs,
|
2010-06-13 17:25:03 +08:00
|
|
|
QualType Canon) {
|
2009-07-31 01:40:51 +08:00
|
|
|
if (!Canon.isNull())
|
|
|
|
Canon = getCanonicalType(Canon);
|
2010-07-02 19:55:11 +08:00
|
|
|
else
|
|
|
|
Canon = getCanonicalTemplateSpecializationType(Template, Args, NumArgs);
|
2009-02-27 06:19:44 +08:00
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
// Allocate the (non-canonical) template specialization type, but don't
|
|
|
|
// try to unique it: these types typically have location information that
|
|
|
|
// we don't unique and don't want to lose.
|
2009-09-09 23:08:12 +08:00
|
|
|
void *Mem = Allocate((sizeof(TemplateSpecializationType) +
|
2009-03-10 07:48:35 +08:00
|
|
|
sizeof(TemplateArgument) * NumArgs),
|
2009-09-25 07:30:46 +08:00
|
|
|
TypeAlignment);
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateSpecializationType *Spec
|
2010-06-11 19:07:21 +08:00
|
|
|
= new (Mem) TemplateSpecializationType(Template,
|
2010-04-27 08:57:59 +08:00
|
|
|
Args, NumArgs,
|
2009-07-30 00:09:57 +08:00
|
|
|
Canon);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-02-10 02:46:07 +08:00
|
|
|
Types.push_back(Spec);
|
2009-09-09 23:08:12 +08:00
|
|
|
return QualType(Spec, 0);
|
2009-02-10 02:46:07 +08:00
|
|
|
}
|
|
|
|
|
2010-07-02 19:55:11 +08:00
|
|
|
QualType
|
|
|
|
ASTContext::getCanonicalTemplateSpecializationType(TemplateName Template,
|
|
|
|
const TemplateArgument *Args,
|
|
|
|
unsigned NumArgs) {
|
|
|
|
// Build the canonical template specialization type.
|
|
|
|
TemplateName CanonTemplate = getCanonicalTemplateName(Template);
|
|
|
|
llvm::SmallVector<TemplateArgument, 4> CanonArgs;
|
|
|
|
CanonArgs.reserve(NumArgs);
|
|
|
|
for (unsigned I = 0; I != NumArgs; ++I)
|
|
|
|
CanonArgs.push_back(getCanonicalTemplateArgument(Args[I]));
|
|
|
|
|
|
|
|
// Determine whether this canonical template specialization type already
|
|
|
|
// exists.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
TemplateSpecializationType::Profile(ID, CanonTemplate,
|
|
|
|
CanonArgs.data(), NumArgs, *this);
|
|
|
|
|
|
|
|
void *InsertPos = 0;
|
|
|
|
TemplateSpecializationType *Spec
|
|
|
|
= TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
|
|
|
|
if (!Spec) {
|
|
|
|
// Allocate a new canonical template specialization type.
|
|
|
|
void *Mem = Allocate((sizeof(TemplateSpecializationType) +
|
|
|
|
sizeof(TemplateArgument) * NumArgs),
|
|
|
|
TypeAlignment);
|
|
|
|
Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
|
|
|
|
CanonArgs.data(), NumArgs,
|
|
|
|
QualType());
|
|
|
|
Types.push_back(Spec);
|
|
|
|
TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(Spec->isDependentType() &&
|
|
|
|
"Non-dependent template-id type must have a canonical type");
|
|
|
|
return QualType(Spec, 0);
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType
|
2010-05-12 05:36:43 +08:00
|
|
|
ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
|
|
|
|
NestedNameSpecifier *NNS,
|
|
|
|
QualType NamedType) {
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
llvm-svn: 67265
2009-03-19 08:18:19 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-05-12 05:36:43 +08:00
|
|
|
ElaboratedType::Profile(ID, Keyword, NNS, NamedType);
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
llvm-svn: 67265
2009-03-19 08:18:19 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
2010-05-12 05:36:43 +08:00
|
|
|
ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
llvm-svn: 67265
2009-03-19 08:18:19 +08:00
|
|
|
if (T)
|
|
|
|
return QualType(T, 0);
|
|
|
|
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
QualType Canon = NamedType;
|
|
|
|
if (!Canon.isCanonical()) {
|
|
|
|
Canon = getCanonicalType(NamedType);
|
2010-05-12 05:36:43 +08:00
|
|
|
ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(!CheckT && "Elaborated canonical type broken");
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
(void)CheckT;
|
|
|
|
}
|
|
|
|
|
2010-05-12 05:36:43 +08:00
|
|
|
T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon);
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
llvm-svn: 67265
2009-03-19 08:18:19 +08:00
|
|
|
Types.push_back(T);
|
2010-05-12 05:36:43 +08:00
|
|
|
ElaboratedTypes.InsertNode(T, InsertPos);
|
Introduce a representation for types that we referred to via a
qualified name, e.g.,
foo::x
so that we retain the nested-name-specifier as written in the source
code and can reproduce that qualified name when printing the types
back (e.g., in diagnostics). This is PR3493, which won't be complete
until finished the other tasks mentioned near the end of this commit.
The parser's representation of nested-name-specifiers, CXXScopeSpec,
is now a bit fatter, because it needs to contain the scopes that
precede each '::' and keep track of whether the global scoping
operator '::' was at the beginning. For example, we need to keep track
of the leading '::', 'foo', and 'bar' in
::foo::bar::x
The Action's CXXScopeTy * is no longer a DeclContext *. It's now the
opaque version of the new NestedNameSpecifier, which contains a single
component of a nested-name-specifier (either a DeclContext * or a Type
*, bitmangled).
The new sugar type QualifiedNameType composes a sequence of
NestedNameSpecifiers with a representation of the type we're actually
referring to. At present, we only build QualifiedNameType nodes within
Sema::getTypeName. This will be extended to other type-constructing
actions (e.g., ActOnClassTemplateId).
Also on the way: QualifiedDeclRefExprs will also store a sequence of
NestedNameSpecifiers, so that we can print out the property
nested-name-specifier. I expect to also use this for handling
dependent names like Fibonacci<I - 1>::value.
llvm-svn: 67265
2009-03-19 08:18:19 +08:00
|
|
|
return QualType(T, 0);
|
|
|
|
}
|
|
|
|
|
2010-04-01 04:19:30 +08:00
|
|
|
QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
|
|
|
|
NestedNameSpecifier *NNS,
|
|
|
|
const IdentifierInfo *Name,
|
|
|
|
QualType Canon) {
|
2009-03-28 07:10:48 +08:00
|
|
|
assert(NNS->isDependent() && "nested-name-specifier must be dependent");
|
|
|
|
|
|
|
|
if (Canon.isNull()) {
|
|
|
|
NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
|
2010-04-01 04:19:30 +08:00
|
|
|
ElaboratedTypeKeyword CanonKeyword = Keyword;
|
|
|
|
if (Keyword == ETK_None)
|
|
|
|
CanonKeyword = ETK_Typename;
|
|
|
|
|
|
|
|
if (CanonNNS != NNS || CanonKeyword != Keyword)
|
|
|
|
Canon = getDependentNameType(CanonKeyword, CanonNNS, Name);
|
2009-03-28 07:10:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-04-01 04:19:30 +08:00
|
|
|
DependentNameType::Profile(ID, Keyword, NNS, Name);
|
2009-03-28 07:10:48 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
2010-04-01 01:34:00 +08:00
|
|
|
DependentNameType *T
|
|
|
|
= DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2009-03-28 07:10:48 +08:00
|
|
|
if (T)
|
|
|
|
return QualType(T, 0);
|
|
|
|
|
2010-04-01 04:19:30 +08:00
|
|
|
T = new (*this) DependentNameType(Keyword, NNS, Name, Canon);
|
2009-03-28 07:10:48 +08:00
|
|
|
Types.push_back(T);
|
2010-04-01 01:34:00 +08:00
|
|
|
DependentNameTypes.InsertNode(T, InsertPos);
|
2009-09-09 23:08:12 +08:00
|
|
|
return QualType(T, 0);
|
2009-03-28 07:10:48 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType
|
2010-06-11 08:33:02 +08:00
|
|
|
ASTContext::getDependentTemplateSpecializationType(
|
|
|
|
ElaboratedTypeKeyword Keyword,
|
2010-04-01 04:19:30 +08:00
|
|
|
NestedNameSpecifier *NNS,
|
2010-06-11 08:33:02 +08:00
|
|
|
const IdentifierInfo *Name,
|
|
|
|
const TemplateArgumentListInfo &Args) {
|
|
|
|
// TODO: avoid this copy
|
|
|
|
llvm::SmallVector<TemplateArgument, 16> ArgCopy;
|
|
|
|
for (unsigned I = 0, E = Args.size(); I != E; ++I)
|
|
|
|
ArgCopy.push_back(Args[I].getArgument());
|
|
|
|
return getDependentTemplateSpecializationType(Keyword, NNS, Name,
|
|
|
|
ArgCopy.size(),
|
|
|
|
ArgCopy.data());
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType
|
|
|
|
ASTContext::getDependentTemplateSpecializationType(
|
|
|
|
ElaboratedTypeKeyword Keyword,
|
|
|
|
NestedNameSpecifier *NNS,
|
|
|
|
const IdentifierInfo *Name,
|
|
|
|
unsigned NumArgs,
|
|
|
|
const TemplateArgument *Args) {
|
2009-04-01 08:28:59 +08:00
|
|
|
assert(NNS->isDependent() && "nested-name-specifier must be dependent");
|
|
|
|
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-06-11 08:33:02 +08:00
|
|
|
DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
|
|
|
|
Name, NumArgs, Args);
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
|
|
|
|
void *InsertPos = 0;
|
2010-06-11 08:33:02 +08:00
|
|
|
DependentTemplateSpecializationType *T
|
|
|
|
= DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
if (T)
|
|
|
|
return QualType(T, 0);
|
|
|
|
|
2010-06-11 08:33:02 +08:00
|
|
|
NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
|
|
|
|
|
|
|
|
ElaboratedTypeKeyword CanonKeyword = Keyword;
|
|
|
|
if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
|
2009-04-01 08:28:59 +08:00
|
|
|
|
2010-06-11 08:33:02 +08:00
|
|
|
bool AnyNonCanonArgs = false;
|
|
|
|
llvm::SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
|
|
|
|
for (unsigned I = 0; I != NumArgs; ++I) {
|
|
|
|
CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
|
|
|
|
if (!CanonArgs[I].structurallyEquals(Args[I]))
|
|
|
|
AnyNonCanonArgs = true;
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
}
|
2009-04-01 08:28:59 +08:00
|
|
|
|
2010-06-11 08:33:02 +08:00
|
|
|
QualType Canon;
|
|
|
|
if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
|
|
|
|
Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
|
|
|
|
Name, NumArgs,
|
|
|
|
CanonArgs.data());
|
|
|
|
|
|
|
|
// Find the insert position again.
|
|
|
|
DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
|
|
|
|
sizeof(TemplateArgument) * NumArgs),
|
|
|
|
TypeAlignment);
|
2010-06-11 19:07:21 +08:00
|
|
|
T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
|
2010-06-11 08:33:02 +08:00
|
|
|
Name, NumArgs, Args, Canon);
|
2009-04-01 08:28:59 +08:00
|
|
|
Types.push_back(T);
|
2010-06-11 08:33:02 +08:00
|
|
|
DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
|
2009-09-09 23:08:12 +08:00
|
|
|
return QualType(T, 0);
|
2009-04-01 08:28:59 +08:00
|
|
|
}
|
|
|
|
|
2008-04-07 12:56:42 +08:00
|
|
|
/// CmpProtocolNames - Comparison predicate for sorting protocols
|
|
|
|
/// alphabetically.
|
|
|
|
static bool CmpProtocolNames(const ObjCProtocolDecl *LHS,
|
|
|
|
const ObjCProtocolDecl *RHS) {
|
2008-11-17 22:58:09 +08:00
|
|
|
return LHS->getDeclName() < RHS->getDeclName();
|
2008-04-07 12:56:42 +08:00
|
|
|
}
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
static bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols,
|
2009-10-23 06:37:11 +08:00
|
|
|
unsigned NumProtocols) {
|
|
|
|
if (NumProtocols == 0) return true;
|
|
|
|
|
|
|
|
for (unsigned i = 1; i != NumProtocols; ++i)
|
|
|
|
if (!CmpProtocolNames(Protocols[i-1], Protocols[i]))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols,
|
2008-04-07 12:56:42 +08:00
|
|
|
unsigned &NumProtocols) {
|
|
|
|
ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 12:56:42 +08:00
|
|
|
// Sort protocols, keyed by name.
|
|
|
|
std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames);
|
|
|
|
|
|
|
|
// Remove duplicates.
|
|
|
|
ProtocolsEnd = std::unique(Protocols, ProtocolsEnd);
|
|
|
|
NumProtocols = ProtocolsEnd-Protocols;
|
|
|
|
}
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
QualType ASTContext::getObjCObjectType(QualType BaseType,
|
|
|
|
ObjCProtocolDecl * const *Protocols,
|
|
|
|
unsigned NumProtocols) {
|
|
|
|
// If the base type is an interface and there aren't any protocols
|
|
|
|
// to add, then the interface type will do just fine.
|
|
|
|
if (!NumProtocols && isa<ObjCInterfaceType>(BaseType))
|
|
|
|
return BaseType;
|
2009-06-18 06:40:22 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// Look in the folding set for an existing type.
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols);
|
2009-06-18 06:40:22 +08:00
|
|
|
void *InsertPos = 0;
|
2010-05-15 19:32:37 +08:00
|
|
|
if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
|
|
|
|
return QualType(QT, 0);
|
2009-06-18 06:40:22 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// Build the canonical type, which has the canonical base type and
|
|
|
|
// a sorted-and-uniqued list of protocols.
|
2009-10-23 06:37:11 +08:00
|
|
|
QualType Canonical;
|
2010-05-15 19:32:37 +08:00
|
|
|
bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols);
|
|
|
|
if (!ProtocolsSorted || !BaseType.isCanonical()) {
|
|
|
|
if (!ProtocolsSorted) {
|
2010-04-28 01:12:11 +08:00
|
|
|
llvm::SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols,
|
|
|
|
Protocols + NumProtocols);
|
2009-10-23 06:37:11 +08:00
|
|
|
unsigned UniqueCount = NumProtocols;
|
|
|
|
|
|
|
|
SortAndUniqueProtocols(&Sorted[0], UniqueCount);
|
2010-05-15 19:32:37 +08:00
|
|
|
Canonical = getObjCObjectType(getCanonicalType(BaseType),
|
|
|
|
&Sorted[0], UniqueCount);
|
2009-10-23 06:37:11 +08:00
|
|
|
} else {
|
2010-05-15 19:32:37 +08:00
|
|
|
Canonical = getObjCObjectType(getCanonicalType(BaseType),
|
|
|
|
Protocols, NumProtocols);
|
2009-10-23 06:37:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Regenerate InsertPos.
|
2010-05-15 19:32:37 +08:00
|
|
|
ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2009-10-23 06:37:11 +08:00
|
|
|
}
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
unsigned Size = sizeof(ObjCObjectTypeImpl);
|
|
|
|
Size += NumProtocols * sizeof(ObjCProtocolDecl *);
|
2010-02-09 06:59:26 +08:00
|
|
|
void *Mem = Allocate(Size, TypeAlignment);
|
2010-05-15 19:32:37 +08:00
|
|
|
ObjCObjectTypeImpl *T =
|
|
|
|
new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
Types.push_back(T);
|
|
|
|
ObjCObjectTypes.InsertNode(T, InsertPos);
|
|
|
|
return QualType(T, 0);
|
2009-06-18 06:40:22 +08:00
|
|
|
}
|
2008-04-07 12:56:42 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
|
|
|
|
/// the given object type.
|
|
|
|
QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) {
|
2007-10-11 08:55:41 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
2010-05-15 19:32:37 +08:00
|
|
|
ObjCObjectPointerType::Profile(ID, ObjectT);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-11 08:55:41 +08:00
|
|
|
void *InsertPos = 0;
|
2010-05-15 19:32:37 +08:00
|
|
|
if (ObjCObjectPointerType *QT =
|
|
|
|
ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
|
2007-10-11 08:55:41 +08:00
|
|
|
return QualType(QT, 0);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// Find the canonical object type.
|
2009-10-23 06:37:11 +08:00
|
|
|
QualType Canonical;
|
2010-05-15 19:32:37 +08:00
|
|
|
if (!ObjectT.isCanonical()) {
|
|
|
|
Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
|
2009-10-23 06:37:11 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// Regenerate InsertPos.
|
|
|
|
ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
|
2009-10-23 06:37:11 +08:00
|
|
|
}
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// No match.
|
|
|
|
void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
|
|
|
|
ObjCObjectPointerType *QType =
|
|
|
|
new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
|
2009-09-30 03:42:55 +08:00
|
|
|
|
|
|
|
Types.push_back(QType);
|
2010-05-15 19:32:37 +08:00
|
|
|
ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
|
2009-09-30 03:42:55 +08:00
|
|
|
return QualType(QType, 0);
|
|
|
|
}
|
|
|
|
|
2010-08-11 20:19:30 +08:00
|
|
|
/// getObjCInterfaceType - Return the unique reference to the type for the
|
|
|
|
/// specified ObjC interface decl. The list of protocols is optional.
|
|
|
|
QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl) {
|
|
|
|
if (Decl->TypeForDecl)
|
|
|
|
return QualType(Decl->TypeForDecl, 0);
|
2010-08-10 05:55:28 +08:00
|
|
|
|
2010-08-11 20:19:30 +08:00
|
|
|
// FIXME: redeclarations?
|
|
|
|
void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
|
|
|
|
ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl);
|
|
|
|
Decl->TypeForDecl = T;
|
|
|
|
Types.push_back(T);
|
|
|
|
return QualType(T, 0);
|
2010-05-15 19:32:37 +08:00
|
|
|
}
|
|
|
|
|
2009-02-27 07:50:07 +08:00
|
|
|
/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
|
|
|
|
/// TypeOfExprType AST's (since expression's are never shared). For example,
|
2007-08-02 02:02:17 +08:00
|
|
|
/// multiple declarations that refer to "typeof(x)" all contain different
|
2009-09-09 23:08:12 +08:00
|
|
|
/// DeclRefExpr's. This doesn't effect the type checker, since it operates
|
2007-08-02 02:02:17 +08:00
|
|
|
/// on canonical type's (which are always unique).
|
2009-02-27 07:50:07 +08:00
|
|
|
QualType ASTContext::getTypeOfExprType(Expr *tofExpr) {
|
2009-07-08 08:03:05 +08:00
|
|
|
TypeOfExprType *toe;
|
2009-07-31 07:18:24 +08:00
|
|
|
if (tofExpr->isTypeDependent()) {
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
DependentTypeOfExprType::Profile(ID, *this, tofExpr);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-31 07:18:24 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
DependentTypeOfExprType *Canon
|
|
|
|
= DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
if (Canon) {
|
|
|
|
// We already have a "canonical" version of an identical, dependent
|
|
|
|
// typeof(expr) type. Use that as our canonical type.
|
2009-09-25 07:30:46 +08:00
|
|
|
toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
|
2009-07-31 07:18:24 +08:00
|
|
|
QualType((TypeOfExprType*)Canon, 0));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Build a new, canonical typeof(expr) type.
|
2009-09-25 07:30:46 +08:00
|
|
|
Canon
|
|
|
|
= new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
|
2009-07-31 07:18:24 +08:00
|
|
|
DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
|
|
|
|
toe = Canon;
|
|
|
|
}
|
|
|
|
} else {
|
2009-07-08 08:03:05 +08:00
|
|
|
QualType Canonical = getCanonicalType(tofExpr->getType());
|
2009-09-25 07:30:46 +08:00
|
|
|
toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
|
2009-07-08 08:03:05 +08:00
|
|
|
}
|
2007-08-02 02:02:17 +08:00
|
|
|
Types.push_back(toe);
|
|
|
|
return QualType(toe, 0);
|
2007-07-31 20:34:36 +08:00
|
|
|
}
|
|
|
|
|
2007-08-02 02:02:17 +08:00
|
|
|
/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
|
|
|
|
/// TypeOfType AST's. The only motivation to unique these nodes would be
|
|
|
|
/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
|
2009-09-09 23:08:12 +08:00
|
|
|
/// an issue. This doesn't effect the type checker, since it operates
|
2007-08-02 02:02:17 +08:00
|
|
|
/// on canonical type's (which are always unique).
|
2007-07-31 20:34:36 +08:00
|
|
|
QualType ASTContext::getTypeOfType(QualType tofType) {
|
2008-04-07 06:59:24 +08:00
|
|
|
QualType Canonical = getCanonicalType(tofType);
|
2009-09-25 07:30:46 +08:00
|
|
|
TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
|
2007-08-02 02:02:17 +08:00
|
|
|
Types.push_back(tot);
|
|
|
|
return QualType(tot, 0);
|
2007-07-31 20:34:36 +08:00
|
|
|
}
|
|
|
|
|
2009-06-25 05:24:56 +08:00
|
|
|
/// getDecltypeForExpr - Given an expr, will return the decltype for that
|
|
|
|
/// expression, according to the rules in C++0x [dcl.type.simple]p4
|
|
|
|
static QualType getDecltypeForExpr(const Expr *e, ASTContext &Context) {
|
2009-06-25 23:00:34 +08:00
|
|
|
if (e->isTypeDependent())
|
|
|
|
return Context.DependentTy;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-25 05:24:56 +08:00
|
|
|
// If e is an id expression or a class member access, decltype(e) is defined
|
|
|
|
// as the type of the entity named by e.
|
|
|
|
if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(e)) {
|
|
|
|
if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl()))
|
|
|
|
return VD->getType();
|
|
|
|
}
|
|
|
|
if (const MemberExpr *ME = dyn_cast<MemberExpr>(e)) {
|
|
|
|
if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
|
|
|
|
return FD->getType();
|
|
|
|
}
|
|
|
|
// If e is a function call or an invocation of an overloaded operator,
|
|
|
|
// (parentheses around e are ignored), decltype(e) is defined as the
|
|
|
|
// return type of that function.
|
|
|
|
if (const CallExpr *CE = dyn_cast<CallExpr>(e->IgnoreParens()))
|
|
|
|
return CE->getCallReturnType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-25 05:24:56 +08:00
|
|
|
QualType T = e->getType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// Otherwise, where T is the type of e, if e is an lvalue, decltype(e) is
|
2009-06-25 05:24:56 +08:00
|
|
|
// defined as T&, otherwise decltype(e) is defined as T.
|
|
|
|
if (e->isLvalue(Context) == Expr::LV_Valid)
|
|
|
|
T = Context.getLValueReferenceType(T);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-25 05:24:56 +08:00
|
|
|
return T;
|
|
|
|
}
|
|
|
|
|
2009-06-25 03:06:50 +08:00
|
|
|
/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique
|
|
|
|
/// DecltypeType AST's. The only motivation to unique these nodes would be
|
|
|
|
/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be
|
2009-09-09 23:08:12 +08:00
|
|
|
/// an issue. This doesn't effect the type checker, since it operates
|
2009-06-25 03:06:50 +08:00
|
|
|
/// on canonical type's (which are always unique).
|
|
|
|
QualType ASTContext::getDecltypeType(Expr *e) {
|
2009-07-08 08:03:05 +08:00
|
|
|
DecltypeType *dt;
|
2009-07-31 07:36:40 +08:00
|
|
|
if (e->isTypeDependent()) {
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
DependentDecltypeType::Profile(ID, *this, e);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-31 07:36:40 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
DependentDecltypeType *Canon
|
|
|
|
= DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
if (Canon) {
|
|
|
|
// We already have a "canonical" version of an equivalent, dependent
|
|
|
|
// decltype type. Use that as our canonical type.
|
2009-09-25 07:30:46 +08:00
|
|
|
dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy,
|
2009-07-31 07:36:40 +08:00
|
|
|
QualType((DecltypeType*)Canon, 0));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Build a new, canonical typeof(expr) type.
|
2009-09-25 07:30:46 +08:00
|
|
|
Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
|
2009-07-31 07:36:40 +08:00
|
|
|
DependentDecltypeTypes.InsertNode(Canon, InsertPos);
|
|
|
|
dt = Canon;
|
|
|
|
}
|
|
|
|
} else {
|
2009-07-08 08:03:05 +08:00
|
|
|
QualType T = getDecltypeForExpr(e, *this);
|
2009-09-25 07:30:46 +08:00
|
|
|
dt = new (*this, TypeAlignment) DecltypeType(e, T, getCanonicalType(T));
|
2009-07-08 08:03:05 +08:00
|
|
|
}
|
2009-06-25 03:06:50 +08:00
|
|
|
Types.push_back(dt);
|
|
|
|
return QualType(dt, 0);
|
|
|
|
}
|
|
|
|
|
2007-01-23 13:45:31 +08:00
|
|
|
/// getTagDeclType - Return the unique reference to the type for the
|
|
|
|
/// specified TagDecl (struct/union/class/enum) decl.
|
2009-08-08 02:05:12 +08:00
|
|
|
QualType ASTContext::getTagDeclType(const TagDecl *Decl) {
|
2007-11-27 05:16:01 +08:00
|
|
|
assert (Decl);
|
2009-08-08 02:05:12 +08:00
|
|
|
// FIXME: What is the design on getTagDeclType when it requires casting
|
|
|
|
// away const? mutable?
|
|
|
|
return getTypeDeclType(const_cast<TagDecl*>(Decl));
|
2007-01-23 13:45:31 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
|
|
|
|
/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
|
|
|
|
/// needs to agree with the definition in <stddef.h>.
|
2009-12-12 08:26:23 +08:00
|
|
|
CanQualType ASTContext::getSizeType() const {
|
2008-11-03 22:12:49 +08:00
|
|
|
return getFromTargetType(Target.getSizeType());
|
2007-04-03 06:35:25 +08:00
|
|
|
}
|
2007-01-23 13:45:31 +08:00
|
|
|
|
2008-08-10 00:51:54 +08:00
|
|
|
/// getSignedWCharType - Return the type of "signed wchar_t".
|
|
|
|
/// Used when in C++, as a GCC extension.
|
|
|
|
QualType ASTContext::getSignedWCharType() const {
|
|
|
|
// FIXME: derive from "Target" ?
|
|
|
|
return WCharTy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
|
|
|
|
/// Used when in C++, as a GCC extension.
|
|
|
|
QualType ASTContext::getUnsignedWCharType() const {
|
|
|
|
// FIXME: derive from "Target" ?
|
|
|
|
return UnsignedIntTy;
|
|
|
|
}
|
|
|
|
|
2007-07-13 11:05:23 +08:00
|
|
|
/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?)
|
|
|
|
/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
|
|
|
|
QualType ASTContext::getPointerDiffType() const {
|
2008-11-03 22:12:49 +08:00
|
|
|
return getFromTargetType(Target.getPtrDiffType(0));
|
2007-07-13 11:05:23 +08:00
|
|
|
}
|
|
|
|
|
2008-04-02 13:18:44 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Type Operators
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-10-23 06:37:11 +08:00
|
|
|
CanQualType ASTContext::getCanonicalParamType(QualType T) {
|
|
|
|
// Push qualifiers into arrays, and then discard any remaining
|
|
|
|
// qualifiers.
|
|
|
|
T = getCanonicalType(T);
|
2010-09-25 01:30:16 +08:00
|
|
|
T = getVariableArrayDecayedType(T);
|
2009-10-23 06:37:11 +08:00
|
|
|
const Type *Ty = T.getTypePtr();
|
|
|
|
QualType Result;
|
|
|
|
if (isa<ArrayType>(Ty)) {
|
|
|
|
Result = getArrayDecayedType(QualType(Ty,0));
|
|
|
|
} else if (isa<FunctionType>(Ty)) {
|
|
|
|
Result = getPointerType(QualType(Ty, 0));
|
|
|
|
} else {
|
|
|
|
Result = QualType(Ty, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return CanQualType::CreateUnsafe(Result);
|
|
|
|
}
|
|
|
|
|
2008-04-07 06:41:35 +08:00
|
|
|
/// getCanonicalType - Return the canonical (structural) type corresponding to
|
|
|
|
/// the specified potentially non-canonical type. The non-canonical version
|
|
|
|
/// of a type may have many "decorated" versions of types. Decorators can
|
|
|
|
/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed
|
|
|
|
/// to be free of any of these, allowing two canonical types to be compared
|
|
|
|
/// for exact equality with a simple pointer comparison.
|
2009-08-05 13:36:45 +08:00
|
|
|
CanQualType ASTContext::getCanonicalType(QualType T) {
|
2009-09-25 03:53:00 +08:00
|
|
|
QualifierCollector Quals;
|
|
|
|
const Type *Ptr = Quals.strip(T);
|
|
|
|
QualType CanType = Ptr->getCanonicalTypeInternal();
|
|
|
|
|
|
|
|
// The canonical internal type will be the canonical type *except*
|
|
|
|
// that we push type qualifiers down through array types.
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If there are no new qualifiers to push down, stop here.
|
|
|
|
if (!Quals.hasQualifiers())
|
2009-08-05 13:36:45 +08:00
|
|
|
return CanQualType::CreateUnsafe(CanType);
|
2008-08-04 15:31:14 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If the type qualifiers are on an array type, get the canonical
|
|
|
|
// type of the array with the qualifiers applied to the element
|
|
|
|
// type.
|
2008-08-04 15:31:14 +08:00
|
|
|
ArrayType *AT = dyn_cast<ArrayType>(CanType);
|
|
|
|
if (!AT)
|
2009-09-25 03:53:00 +08:00
|
|
|
return CanQualType::CreateUnsafe(getQualifiedType(CanType, Quals));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
// Get the canonical version of the element with the extra qualifiers on it.
|
|
|
|
// This can recursively sink qualifiers through multiple levels of arrays.
|
2009-09-25 03:53:00 +08:00
|
|
|
QualType NewEltTy = getQualifiedType(AT->getElementType(), Quals);
|
2008-08-04 15:31:14 +08:00
|
|
|
NewEltTy = getCanonicalType(NewEltTy);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
if (ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
|
2009-08-05 13:36:45 +08:00
|
|
|
return CanQualType::CreateUnsafe(
|
|
|
|
getConstantArrayType(NewEltTy, CAT->getSize(),
|
|
|
|
CAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
CAT->getIndexTypeCVRQualifiers()));
|
2008-08-04 15:31:14 +08:00
|
|
|
if (IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT))
|
2009-08-05 13:36:45 +08:00
|
|
|
return CanQualType::CreateUnsafe(
|
|
|
|
getIncompleteArrayType(NewEltTy, IAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
IAT->getIndexTypeCVRQualifiers()));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-12-06 07:32:09 +08:00
|
|
|
if (DependentSizedArrayType *DSAT = dyn_cast<DependentSizedArrayType>(AT))
|
2009-08-05 13:36:45 +08:00
|
|
|
return CanQualType::CreateUnsafe(
|
|
|
|
getDependentSizedArrayType(NewEltTy,
|
2009-08-15 10:50:32 +08:00
|
|
|
DSAT->getSizeExpr() ?
|
|
|
|
DSAT->getSizeExpr()->Retain() : 0,
|
2009-08-05 13:36:45 +08:00
|
|
|
DSAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
DSAT->getIndexTypeCVRQualifiers(),
|
2009-10-31 06:56:57 +08:00
|
|
|
DSAT->getBracketsRange())->getCanonicalTypeInternal());
|
2008-12-06 07:32:09 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
VariableArrayType *VAT = cast<VariableArrayType>(AT);
|
2009-08-05 13:36:45 +08:00
|
|
|
return CanQualType::CreateUnsafe(getVariableArrayType(NewEltTy,
|
2009-08-15 10:50:32 +08:00
|
|
|
VAT->getSizeExpr() ?
|
|
|
|
VAT->getSizeExpr()->Retain() : 0,
|
2009-08-05 13:36:45 +08:00
|
|
|
VAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
VAT->getIndexTypeCVRQualifiers(),
|
2009-08-05 13:36:45 +08:00
|
|
|
VAT->getBracketsRange()));
|
2008-08-04 15:31:14 +08:00
|
|
|
}
|
|
|
|
|
2009-12-29 15:16:59 +08:00
|
|
|
QualType ASTContext::getUnqualifiedArrayType(QualType T,
|
|
|
|
Qualifiers &Quals) {
|
2010-01-13 04:32:25 +08:00
|
|
|
Quals = T.getQualifiers();
|
2010-05-18 02:45:21 +08:00
|
|
|
const ArrayType *AT = getAsArrayType(T);
|
|
|
|
if (!AT) {
|
2010-01-13 04:32:25 +08:00
|
|
|
return T.getUnqualifiedType();
|
2009-12-29 15:16:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
QualType Elt = AT->getElementType();
|
2010-01-05 16:15:06 +08:00
|
|
|
QualType UnqualElt = getUnqualifiedArrayType(Elt, Quals);
|
2009-12-29 15:16:59 +08:00
|
|
|
if (Elt == UnqualElt)
|
|
|
|
return T;
|
|
|
|
|
2010-05-18 02:45:21 +08:00
|
|
|
if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) {
|
2009-12-29 15:16:59 +08:00
|
|
|
return getConstantArrayType(UnqualElt, CAT->getSize(),
|
|
|
|
CAT->getSizeModifier(), 0);
|
|
|
|
}
|
|
|
|
|
2010-05-18 02:45:21 +08:00
|
|
|
if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
|
2009-12-29 15:16:59 +08:00
|
|
|
return getIncompleteArrayType(UnqualElt, IAT->getSizeModifier(), 0);
|
|
|
|
}
|
|
|
|
|
2010-05-18 02:45:21 +08:00
|
|
|
if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) {
|
|
|
|
return getVariableArrayType(UnqualElt,
|
|
|
|
VAT->getSizeExpr() ?
|
|
|
|
VAT->getSizeExpr()->Retain() : 0,
|
|
|
|
VAT->getSizeModifier(),
|
|
|
|
VAT->getIndexTypeCVRQualifiers(),
|
|
|
|
VAT->getBracketsRange());
|
|
|
|
}
|
|
|
|
|
|
|
|
const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT);
|
2009-12-29 15:16:59 +08:00
|
|
|
return getDependentSizedArrayType(UnqualElt, DSAT->getSizeExpr()->Retain(),
|
|
|
|
DSAT->getSizeModifier(), 0,
|
|
|
|
SourceRange());
|
|
|
|
}
|
|
|
|
|
2010-06-09 11:53:18 +08:00
|
|
|
/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that
|
|
|
|
/// may be similar (C++ 4.4), replaces T1 and T2 with the type that
|
|
|
|
/// they point to and return true. If T1 and T2 aren't pointer types
|
|
|
|
/// or pointer-to-member types, or if they are not similar at this
|
|
|
|
/// level, returns false and leaves T1 and T2 unchanged. Top-level
|
|
|
|
/// qualifiers on T1 and T2 are ignored. This function will typically
|
|
|
|
/// be called in a loop that successively "unwraps" pointer and
|
|
|
|
/// pointer-to-member types to compare them at each level.
|
|
|
|
bool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) {
|
|
|
|
const PointerType *T1PtrType = T1->getAs<PointerType>(),
|
|
|
|
*T2PtrType = T2->getAs<PointerType>();
|
|
|
|
if (T1PtrType && T2PtrType) {
|
|
|
|
T1 = T1PtrType->getPointeeType();
|
|
|
|
T2 = T2PtrType->getPointeeType();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
|
|
|
|
*T2MPType = T2->getAs<MemberPointerType>();
|
|
|
|
if (T1MPType && T2MPType &&
|
|
|
|
hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
|
|
|
|
QualType(T2MPType->getClass(), 0))) {
|
|
|
|
T1 = T1MPType->getPointeeType();
|
|
|
|
T2 = T2MPType->getPointeeType();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getLangOptions().ObjC1) {
|
|
|
|
const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(),
|
|
|
|
*T2OPType = T2->getAs<ObjCObjectPointerType>();
|
|
|
|
if (T1OPType && T2OPType) {
|
|
|
|
T1 = T1OPType->getPointeeType();
|
|
|
|
T2 = T2OPType->getPointeeType();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Block pointers, too?
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-08-12 06:01:17 +08:00
|
|
|
DeclarationNameInfo ASTContext::getNameForTemplate(TemplateName Name,
|
|
|
|
SourceLocation NameLoc) {
|
2009-11-25 02:42:40 +08:00
|
|
|
if (TemplateDecl *TD = Name.getAsTemplateDecl())
|
2010-08-12 06:01:17 +08:00
|
|
|
// DNInfo work in progress: CHECKME: what about DNLoc?
|
|
|
|
return DeclarationNameInfo(TD->getDeclName(), NameLoc);
|
|
|
|
|
2009-11-25 02:42:40 +08:00
|
|
|
if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
|
2010-08-12 06:01:17 +08:00
|
|
|
DeclarationName DName;
|
2009-11-25 02:42:40 +08:00
|
|
|
if (DTN->isIdentifier()) {
|
2010-08-12 06:01:17 +08:00
|
|
|
DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
|
|
|
|
return DeclarationNameInfo(DName, NameLoc);
|
2009-11-25 02:42:40 +08:00
|
|
|
} else {
|
2010-08-12 06:01:17 +08:00
|
|
|
DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
|
|
|
|
// DNInfo work in progress: FIXME: source locations?
|
|
|
|
DeclarationNameLoc DNLoc;
|
|
|
|
DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
|
|
|
|
DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
|
|
|
|
return DeclarationNameInfo(DName, NameLoc, DNLoc);
|
2009-11-25 02:42:40 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-02 16:04:21 +08:00
|
|
|
OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
|
|
|
|
assert(Storage);
|
2010-08-12 06:01:17 +08:00
|
|
|
// DNInfo work in progress: CHECKME: what about DNLoc?
|
|
|
|
return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
|
2009-11-25 02:42:40 +08:00
|
|
|
}
|
|
|
|
|
2009-05-07 14:41:52 +08:00
|
|
|
TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) {
|
2010-06-17 05:09:37 +08:00
|
|
|
if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
|
|
|
|
if (TemplateTemplateParmDecl *TTP
|
|
|
|
= dyn_cast<TemplateTemplateParmDecl>(Template))
|
|
|
|
Template = getCanonicalTemplateTemplateParmDecl(TTP);
|
|
|
|
|
|
|
|
// The canonical template name is the canonical template declaration.
|
2009-07-18 08:34:25 +08:00
|
|
|
return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
|
2010-06-17 05:09:37 +08:00
|
|
|
}
|
2009-05-07 14:41:52 +08:00
|
|
|
|
2009-12-02 16:04:21 +08:00
|
|
|
assert(!Name.getAsOverloadedTemplate());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-07 14:41:52 +08:00
|
|
|
DependentTemplateName *DTN = Name.getAsDependentTemplateName();
|
|
|
|
assert(DTN && "Non-dependent template names must refer to template decls.");
|
|
|
|
return DTN->CanonicalTemplateName;
|
|
|
|
}
|
|
|
|
|
2009-11-12 07:06:43 +08:00
|
|
|
bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
|
|
|
|
X = getCanonicalTemplateName(X);
|
|
|
|
Y = getCanonicalTemplateName(Y);
|
|
|
|
return X.getAsVoidPointer() == Y.getAsVoidPointer();
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateArgument
|
2009-07-29 07:00:59 +08:00
|
|
|
ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) {
|
|
|
|
switch (Arg.getKind()) {
|
|
|
|
case TemplateArgument::Null:
|
|
|
|
return Arg;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
case TemplateArgument::Expression:
|
|
|
|
return Arg;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
case TemplateArgument::Declaration:
|
2009-10-29 16:12:44 +08:00
|
|
|
return TemplateArgument(Arg.getAsDecl()->getCanonicalDecl());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-11 09:00:40 +08:00
|
|
|
case TemplateArgument::Template:
|
|
|
|
return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
|
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
case TemplateArgument::Integral:
|
2009-10-29 16:12:44 +08:00
|
|
|
return TemplateArgument(*Arg.getAsIntegral(),
|
2009-07-29 07:00:59 +08:00
|
|
|
getCanonicalType(Arg.getIntegralType()));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
case TemplateArgument::Type:
|
2009-10-29 16:12:44 +08:00
|
|
|
return TemplateArgument(getCanonicalType(Arg.getAsType()));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
case TemplateArgument::Pack: {
|
|
|
|
// FIXME: Allocate in ASTContext
|
|
|
|
TemplateArgument *CanonArgs = new TemplateArgument[Arg.pack_size()];
|
|
|
|
unsigned Idx = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
|
2009-07-29 07:00:59 +08:00
|
|
|
AEnd = Arg.pack_end();
|
|
|
|
A != AEnd; (void)++A, ++Idx)
|
|
|
|
CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-29 07:00:59 +08:00
|
|
|
TemplateArgument Result;
|
|
|
|
Result.setArgumentPack(CanonArgs, Arg.pack_size(), false);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Silence GCC warning
|
|
|
|
assert(false && "Unhandled template argument kind");
|
|
|
|
return TemplateArgument();
|
|
|
|
}
|
|
|
|
|
2009-03-28 07:10:48 +08:00
|
|
|
NestedNameSpecifier *
|
|
|
|
ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) {
|
2009-09-09 23:08:12 +08:00
|
|
|
if (!NNS)
|
2009-03-28 07:10:48 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (NNS->getKind()) {
|
|
|
|
case NestedNameSpecifier::Identifier:
|
|
|
|
// Canonicalize the prefix but keep the identifier the same.
|
2009-09-09 23:08:12 +08:00
|
|
|
return NestedNameSpecifier::Create(*this,
|
2009-03-28 07:10:48 +08:00
|
|
|
getCanonicalNestedNameSpecifier(NNS->getPrefix()),
|
|
|
|
NNS->getAsIdentifier());
|
|
|
|
|
|
|
|
case NestedNameSpecifier::Namespace:
|
|
|
|
// A namespace is canonical; build a nested-name-specifier with
|
|
|
|
// this namespace and no prefix.
|
|
|
|
return NestedNameSpecifier::Create(*this, 0, NNS->getAsNamespace());
|
|
|
|
|
|
|
|
case NestedNameSpecifier::TypeSpec:
|
|
|
|
case NestedNameSpecifier::TypeSpecWithTemplate: {
|
|
|
|
QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
|
2009-09-09 23:08:12 +08:00
|
|
|
return NestedNameSpecifier::Create(*this, 0,
|
|
|
|
NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
|
2009-03-28 07:10:48 +08:00
|
|
|
T.getTypePtr());
|
|
|
|
}
|
|
|
|
|
|
|
|
case NestedNameSpecifier::Global:
|
|
|
|
// The global specifier is canonical and unique.
|
|
|
|
return NNS;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Required to silence a GCC warning
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
|
|
|
|
const ArrayType *ASTContext::getAsArrayType(QualType T) {
|
|
|
|
// Handle the non-qualified case efficiently.
|
First part of changes to eliminate problems with cv-qualifiers and
sugared types. The basic problem is that our qualifier accessors
(getQualifiers, getCVRQualifiers, isConstQualified, etc.) only look at
the current QualType and not at any qualifiers that come from sugared
types, meaning that we won't see these qualifiers through, e.g.,
typedefs:
typedef const int CInt;
typedef CInt Self;
Self.isConstQualified() currently returns false!
Various bugs (e.g., PR5383) have cropped up all over the front end due
to such problems. I'm addressing this problem by splitting each
qualifier accessor into two versions:
- the "local" version only returns qualifiers on this particular
QualType instance
- the "normal" version that will eventually combine qualifiers from this
QualType instance with the qualifiers on the canonical type to
produce the full set of qualifiers.
This commit adds the local versions and switches a few callers from
the "normal" version (e.g., isConstQualified) over to the "local"
version (e.g., isLocalConstQualified) when that is the right thing to
do, e.g., because we're printing or serializing the qualifiers. Also,
switch a bunch of
Context.getCanonicalType(T1).getUnqualifiedType() == Context.getCanonicalType(T2).getQualifiedType()
expressions over to
Context.hasSameUnqualifiedType(T1, T2)
llvm-svn: 88969
2009-11-17 05:35:15 +08:00
|
|
|
if (!T.hasLocalQualifiers()) {
|
2008-08-04 15:31:14 +08:00
|
|
|
// Handle the common positive case fast.
|
|
|
|
if (const ArrayType *AT = dyn_cast<ArrayType>(T))
|
|
|
|
return AT;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// Handle the common negative case fast.
|
2008-08-04 15:31:14 +08:00
|
|
|
QualType CType = T->getCanonicalTypeInternal();
|
2009-09-25 03:53:00 +08:00
|
|
|
if (!isa<ArrayType>(CType))
|
2008-08-04 15:31:14 +08:00
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// Apply any qualifiers from the array type to the element type. This
|
2008-08-04 15:31:14 +08:00
|
|
|
// implements C99 6.7.3p8: "If the specification of an array type includes
|
|
|
|
// any type qualifiers, the element type is so qualified, not the array type."
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
// If we get here, we either have type qualifiers on the type, or we have
|
|
|
|
// sugar such as a typedef in the way. If we have type qualifiers on the type
|
2009-08-05 13:36:45 +08:00
|
|
|
// we must propagate them down into the element type.
|
2009-09-25 03:53:00 +08:00
|
|
|
|
|
|
|
QualifierCollector Qs;
|
|
|
|
const Type *Ty = Qs.strip(T.getDesugaredType());
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
// If we have a simple case, just return now.
|
|
|
|
const ArrayType *ATy = dyn_cast<ArrayType>(Ty);
|
2009-09-25 03:53:00 +08:00
|
|
|
if (ATy == 0 || Qs.empty())
|
2008-08-04 15:31:14 +08:00
|
|
|
return ATy;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
// Otherwise, we have an array and we have qualifiers on it. Push the
|
|
|
|
// qualifiers into the array element type and return a new array type.
|
|
|
|
// Get the canonical version of the element with the extra qualifiers on it.
|
|
|
|
// This can recursively sink qualifiers through multiple levels of arrays.
|
2009-09-25 03:53:00 +08:00
|
|
|
QualType NewEltTy = getQualifiedType(ATy->getElementType(), Qs);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy))
|
|
|
|
return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
|
|
|
|
CAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
CAT->getIndexTypeCVRQualifiers()));
|
2008-08-04 15:31:14 +08:00
|
|
|
if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy))
|
|
|
|
return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
|
|
|
|
IAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
IAT->getIndexTypeCVRQualifiers()));
|
2008-12-06 07:32:09 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const DependentSizedArrayType *DSAT
|
2008-12-06 07:32:09 +08:00
|
|
|
= dyn_cast<DependentSizedArrayType>(ATy))
|
|
|
|
return cast<ArrayType>(
|
2009-09-09 23:08:12 +08:00
|
|
|
getDependentSizedArrayType(NewEltTy,
|
2009-08-15 10:50:32 +08:00
|
|
|
DSAT->getSizeExpr() ?
|
|
|
|
DSAT->getSizeExpr()->Retain() : 0,
|
2008-12-06 07:32:09 +08:00
|
|
|
DSAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
DSAT->getIndexTypeCVRQualifiers(),
|
2009-07-06 23:59:29 +08:00
|
|
|
DSAT->getBracketsRange()));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
const VariableArrayType *VAT = cast<VariableArrayType>(ATy);
|
2009-07-06 23:59:29 +08:00
|
|
|
return cast<ArrayType>(getVariableArrayType(NewEltTy,
|
2009-08-15 10:50:32 +08:00
|
|
|
VAT->getSizeExpr() ?
|
2009-09-25 03:53:00 +08:00
|
|
|
VAT->getSizeExpr()->Retain() : 0,
|
2008-08-04 15:31:14 +08:00
|
|
|
VAT->getSizeModifier(),
|
2009-09-25 03:53:00 +08:00
|
|
|
VAT->getIndexTypeCVRQualifiers(),
|
2009-07-06 23:59:29 +08:00
|
|
|
VAT->getBracketsRange()));
|
2008-04-07 06:41:35 +08:00
|
|
|
}
|
|
|
|
|
2008-04-02 13:18:44 +08:00
|
|
|
/// getArrayDecayedType - Return the properly qualified result of decaying the
|
|
|
|
/// specified array type to a pointer. This operation is non-trivial when
|
|
|
|
/// handling typedefs etc. The canonical type of "T" must be an array type,
|
|
|
|
/// this returns a pointer to a properly qualified element of the array.
|
|
|
|
///
|
|
|
|
/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
|
|
|
|
QualType ASTContext::getArrayDecayedType(QualType Ty) {
|
2008-08-04 15:31:14 +08:00
|
|
|
// Get the element type with 'getAsArrayType' so that we don't lose any
|
|
|
|
// typedefs in the element type of the array. This also handles propagation
|
|
|
|
// of type qualifiers from the array type into the element type if present
|
|
|
|
// (C99 6.7.3p8).
|
|
|
|
const ArrayType *PrettyArrayType = getAsArrayType(Ty);
|
|
|
|
assert(PrettyArrayType && "Not an array type!");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-04 15:31:14 +08:00
|
|
|
QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
|
2008-04-02 13:18:44 +08:00
|
|
|
|
|
|
|
// int x[restrict 4] -> int *restrict
|
2009-09-25 03:53:00 +08:00
|
|
|
return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers());
|
2008-04-02 13:18:44 +08:00
|
|
|
}
|
|
|
|
|
2009-07-24 07:49:00 +08:00
|
|
|
QualType ASTContext::getBaseElementType(QualType QT) {
|
2009-09-25 03:53:00 +08:00
|
|
|
QualifierCollector Qs;
|
2010-04-28 01:12:11 +08:00
|
|
|
while (const ArrayType *AT = getAsArrayType(QualType(Qs.strip(QT), 0)))
|
|
|
|
QT = AT->getElementType();
|
|
|
|
return Qs.apply(QT);
|
2009-07-24 07:49:00 +08:00
|
|
|
}
|
|
|
|
|
2009-09-25 09:23:32 +08:00
|
|
|
QualType ASTContext::getBaseElementType(const ArrayType *AT) {
|
|
|
|
QualType ElemTy = AT->getElementType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-25 09:23:32 +08:00
|
|
|
if (const ArrayType *AT = getAsArrayType(ElemTy))
|
|
|
|
return getBaseElementType(AT);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-12-21 11:44:36 +08:00
|
|
|
return ElemTy;
|
|
|
|
}
|
|
|
|
|
2009-08-22 00:31:06 +08:00
|
|
|
/// getConstantArrayElementCount - Returns number of constant array elements.
|
2009-09-09 23:08:12 +08:00
|
|
|
uint64_t
|
2009-08-22 00:31:06 +08:00
|
|
|
ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const {
|
|
|
|
uint64_t ElementCount = 1;
|
|
|
|
do {
|
|
|
|
ElementCount *= CA->getSize().getZExtValue();
|
|
|
|
CA = dyn_cast<ConstantArrayType>(CA->getElementType());
|
|
|
|
} while (CA);
|
|
|
|
return ElementCount;
|
|
|
|
}
|
|
|
|
|
2007-04-28 05:51:21 +08:00
|
|
|
/// getFloatingRank - Return a relative rank for floating point types.
|
|
|
|
/// This routine will assert if passed a built-in type that isn't a float.
|
2008-04-07 07:38:49 +08:00
|
|
|
static FloatingRank getFloatingRank(QualType T) {
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const ComplexType *CT = T->getAs<ComplexType>())
|
2007-06-23 04:56:16 +08:00
|
|
|
return getFloatingRank(CT->getElementType());
|
2008-04-07 07:38:49 +08:00
|
|
|
|
2009-09-22 07:43:11 +08:00
|
|
|
assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
|
|
|
|
switch (T->getAs<BuiltinType>()->getKind()) {
|
2008-04-07 07:38:49 +08:00
|
|
|
default: assert(0 && "getFloatingRank(): not a floating type");
|
2007-06-23 04:56:16 +08:00
|
|
|
case BuiltinType::Float: return FloatRank;
|
|
|
|
case BuiltinType::Double: return DoubleRank;
|
|
|
|
case BuiltinType::LongDouble: return LongDoubleRank;
|
2007-04-28 02:30:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
|
|
|
|
/// point or a complex type (based on typeDomain/typeSize).
|
2007-08-27 09:41:48 +08:00
|
|
|
/// 'typeDomain' is a real floating point or complex type.
|
|
|
|
/// 'typeSize' is a real floating point or complex type.
|
2008-04-07 07:58:54 +08:00
|
|
|
QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
|
|
|
|
QualType Domain) const {
|
|
|
|
FloatingRank EltRank = getFloatingRank(Size);
|
|
|
|
if (Domain->isComplexType()) {
|
|
|
|
switch (EltRank) {
|
2007-08-27 09:41:48 +08:00
|
|
|
default: assert(0 && "getFloatingRank(): illegal value for rank");
|
2007-08-27 09:27:54 +08:00
|
|
|
case FloatRank: return FloatComplexTy;
|
|
|
|
case DoubleRank: return DoubleComplexTy;
|
|
|
|
case LongDoubleRank: return LongDoubleComplexTy;
|
|
|
|
}
|
|
|
|
}
|
2008-04-07 07:58:54 +08:00
|
|
|
|
|
|
|
assert(Domain->isRealFloatingType() && "Unknown domain!");
|
|
|
|
switch (EltRank) {
|
|
|
|
default: assert(0 && "getFloatingRank(): illegal value for rank");
|
|
|
|
case FloatRank: return FloatTy;
|
|
|
|
case DoubleRank: return DoubleTy;
|
|
|
|
case LongDoubleRank: return LongDoubleTy;
|
2007-04-28 05:51:21 +08:00
|
|
|
}
|
2007-04-28 02:30:00 +08:00
|
|
|
}
|
|
|
|
|
2008-04-07 07:55:33 +08:00
|
|
|
/// getFloatingTypeOrder - Compare the rank of the two specified floating
|
|
|
|
/// point types, ignoring the domain of the type (i.e. 'double' ==
|
|
|
|
/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
|
2009-09-09 23:08:12 +08:00
|
|
|
/// LHS < RHS, return -1.
|
2008-04-07 07:38:49 +08:00
|
|
|
int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) {
|
|
|
|
FloatingRank LHSR = getFloatingRank(LHS);
|
|
|
|
FloatingRank RHSR = getFloatingRank(RHS);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 07:38:49 +08:00
|
|
|
if (LHSR == RHSR)
|
2007-08-27 23:30:22 +08:00
|
|
|
return 0;
|
2008-04-07 07:38:49 +08:00
|
|
|
if (LHSR > RHSR)
|
2007-08-27 23:30:22 +08:00
|
|
|
return 1;
|
|
|
|
return -1;
|
2007-04-28 02:30:00 +08:00
|
|
|
}
|
|
|
|
|
2008-04-07 06:59:24 +08:00
|
|
|
/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
|
|
|
|
/// routine will assert if passed a built-in type that isn't an integer or enum,
|
|
|
|
/// or if it is not canonicalized.
|
2009-02-13 10:31:07 +08:00
|
|
|
unsigned ASTContext::getIntegerRank(Type *T) {
|
2009-10-23 04:10:53 +08:00
|
|
|
assert(T->isCanonicalUnqualified() && "T should be canonicalized");
|
2009-02-13 10:31:07 +08:00
|
|
|
if (EnumType* ET = dyn_cast<EnumType>(T))
|
2009-12-09 17:09:27 +08:00
|
|
|
T = ET->getDecl()->getPromotionType().getTypePtr();
|
2009-02-13 10:31:07 +08:00
|
|
|
|
2009-07-06 07:44:27 +08:00
|
|
|
if (T->isSpecificBuiltinType(BuiltinType::WChar))
|
|
|
|
T = getFromTargetType(Target.getWCharType()).getTypePtr();
|
|
|
|
|
2009-07-14 14:30:34 +08:00
|
|
|
if (T->isSpecificBuiltinType(BuiltinType::Char16))
|
|
|
|
T = getFromTargetType(Target.getChar16Type()).getTypePtr();
|
|
|
|
|
|
|
|
if (T->isSpecificBuiltinType(BuiltinType::Char32))
|
|
|
|
T = getFromTargetType(Target.getChar32Type()).getTypePtr();
|
|
|
|
|
2008-04-07 06:59:24 +08:00
|
|
|
switch (cast<BuiltinType>(T)->getKind()) {
|
2008-04-07 07:55:33 +08:00
|
|
|
default: assert(0 && "getIntegerRank(): not a built-in integer");
|
|
|
|
case BuiltinType::Bool:
|
2009-02-13 10:31:07 +08:00
|
|
|
return 1 + (getIntWidth(BoolTy) << 3);
|
2008-04-07 07:55:33 +08:00
|
|
|
case BuiltinType::Char_S:
|
|
|
|
case BuiltinType::Char_U:
|
|
|
|
case BuiltinType::SChar:
|
|
|
|
case BuiltinType::UChar:
|
2009-02-13 10:31:07 +08:00
|
|
|
return 2 + (getIntWidth(CharTy) << 3);
|
2008-04-07 07:55:33 +08:00
|
|
|
case BuiltinType::Short:
|
|
|
|
case BuiltinType::UShort:
|
2009-02-13 10:31:07 +08:00
|
|
|
return 3 + (getIntWidth(ShortTy) << 3);
|
2008-04-07 07:55:33 +08:00
|
|
|
case BuiltinType::Int:
|
|
|
|
case BuiltinType::UInt:
|
2009-02-13 10:31:07 +08:00
|
|
|
return 4 + (getIntWidth(IntTy) << 3);
|
2008-04-07 07:55:33 +08:00
|
|
|
case BuiltinType::Long:
|
|
|
|
case BuiltinType::ULong:
|
2009-02-13 10:31:07 +08:00
|
|
|
return 5 + (getIntWidth(LongTy) << 3);
|
2008-04-07 07:55:33 +08:00
|
|
|
case BuiltinType::LongLong:
|
|
|
|
case BuiltinType::ULongLong:
|
2009-02-13 10:31:07 +08:00
|
|
|
return 6 + (getIntWidth(LongLongTy) << 3);
|
2009-04-30 10:43:43 +08:00
|
|
|
case BuiltinType::Int128:
|
|
|
|
case BuiltinType::UInt128:
|
|
|
|
return 7 + (getIntWidth(Int128Ty) << 3);
|
2008-04-07 06:59:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-20 12:21:42 +08:00
|
|
|
/// \brief Whether this is a promotable bitfield reference according
|
|
|
|
/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
|
|
|
|
///
|
|
|
|
/// \returns the type this bit-field will promote to, or NULL if no
|
|
|
|
/// promotion occurs.
|
|
|
|
QualType ASTContext::isPromotableBitField(Expr *E) {
|
2010-05-25 04:13:53 +08:00
|
|
|
if (E->isTypeDependent() || E->isValueDependent())
|
|
|
|
return QualType();
|
|
|
|
|
2009-08-20 12:21:42 +08:00
|
|
|
FieldDecl *Field = E->getBitField();
|
|
|
|
if (!Field)
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
QualType FT = Field->getType();
|
|
|
|
|
|
|
|
llvm::APSInt BitWidthAP = Field->getBitWidth()->EvaluateAsInt(*this);
|
|
|
|
uint64_t BitWidth = BitWidthAP.getZExtValue();
|
|
|
|
uint64_t IntSize = getTypeSize(IntTy);
|
|
|
|
// GCC extension compatibility: if the bit-field size is less than or equal
|
|
|
|
// to the size of int, it gets promoted no matter what its type is.
|
|
|
|
// For instance, unsigned long bf : 4 gets promoted to signed int.
|
|
|
|
if (BitWidth < IntSize)
|
|
|
|
return IntTy;
|
|
|
|
|
|
|
|
if (BitWidth == IntSize)
|
|
|
|
return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
|
|
|
|
|
|
|
|
// Types bigger than int are not subject to promotions, and therefore act
|
|
|
|
// like the base type.
|
|
|
|
// FIXME: This doesn't quite match what gcc does, but what gcc does here
|
|
|
|
// is ridiculous.
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
2009-08-19 15:44:53 +08:00
|
|
|
/// getPromotedIntegerType - Returns the type that Promotable will
|
|
|
|
/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
|
|
|
|
/// integer type.
|
|
|
|
QualType ASTContext::getPromotedIntegerType(QualType Promotable) {
|
|
|
|
assert(!Promotable.isNull());
|
|
|
|
assert(Promotable->isPromotableIntegerType());
|
2009-12-09 17:09:27 +08:00
|
|
|
if (const EnumType *ET = Promotable->getAs<EnumType>())
|
|
|
|
return ET->getDecl()->getPromotionType();
|
2009-08-19 15:44:53 +08:00
|
|
|
if (Promotable->isSignedIntegerType())
|
|
|
|
return IntTy;
|
|
|
|
uint64_t PromotableSize = getTypeSize(Promotable);
|
|
|
|
uint64_t IntSize = getTypeSize(IntTy);
|
|
|
|
assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize);
|
|
|
|
return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// getIntegerTypeOrder - Returns the highest ranked integer type:
|
2008-04-07 07:55:33 +08:00
|
|
|
/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
|
2009-09-09 23:08:12 +08:00
|
|
|
/// LHS < RHS, return -1.
|
2008-04-07 07:55:33 +08:00
|
|
|
int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) {
|
2008-04-07 06:59:24 +08:00
|
|
|
Type *LHSC = getCanonicalType(LHS).getTypePtr();
|
|
|
|
Type *RHSC = getCanonicalType(RHS).getTypePtr();
|
2008-04-07 07:55:33 +08:00
|
|
|
if (LHSC == RHSC) return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 06:59:24 +08:00
|
|
|
bool LHSUnsigned = LHSC->isUnsignedIntegerType();
|
|
|
|
bool RHSUnsigned = RHSC->isUnsignedIntegerType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 07:55:33 +08:00
|
|
|
unsigned LHSRank = getIntegerRank(LHSC);
|
|
|
|
unsigned RHSRank = getIntegerRank(RHSC);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 07:55:33 +08:00
|
|
|
if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
|
|
|
|
if (LHSRank == RHSRank) return 0;
|
|
|
|
return LHSRank > RHSRank ? 1 : -1;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 07:55:33 +08:00
|
|
|
// Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
|
|
|
|
if (LHSUnsigned) {
|
|
|
|
// If the unsigned [LHS] type is larger, return it.
|
|
|
|
if (LHSRank >= RHSRank)
|
|
|
|
return 1;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 07:55:33 +08:00
|
|
|
// If the signed type can represent all values of the unsigned type, it
|
|
|
|
// wins. Because we are dealing with 2's complement and types that are
|
2009-09-09 23:08:12 +08:00
|
|
|
// powers of two larger than each other, this is always safe.
|
2008-04-07 07:55:33 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the unsigned [RHS] type is larger, return it.
|
|
|
|
if (RHSRank >= LHSRank)
|
|
|
|
return -1;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 07:55:33 +08:00
|
|
|
// If the signed type can represent all values of the unsigned type, it
|
|
|
|
// wins. Because we are dealing with 2's complement and types that are
|
2009-09-09 23:08:12 +08:00
|
|
|
// powers of two larger than each other, this is always safe.
|
2008-04-07 07:55:33 +08:00
|
|
|
return 1;
|
2007-04-28 02:30:00 +08:00
|
|
|
}
|
2007-08-17 13:31:46 +08:00
|
|
|
|
2009-11-15 05:45:58 +08:00
|
|
|
static RecordDecl *
|
|
|
|
CreateRecordDecl(ASTContext &Ctx, RecordDecl::TagKind TK, DeclContext *DC,
|
|
|
|
SourceLocation L, IdentifierInfo *Id) {
|
|
|
|
if (Ctx.getLangOptions().CPlusPlus)
|
|
|
|
return CXXRecordDecl::Create(Ctx, TK, DC, L, Id);
|
|
|
|
else
|
|
|
|
return RecordDecl::Create(Ctx, TK, DC, L, Id);
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
// getCFConstantStringType - Return the type used for constant CFStrings.
|
2007-08-17 13:31:46 +08:00
|
|
|
QualType ASTContext::getCFConstantStringType() {
|
|
|
|
if (!CFConstantStringTypeDecl) {
|
2009-09-09 23:08:12 +08:00
|
|
|
CFConstantStringTypeDecl =
|
2010-05-12 05:36:43 +08:00
|
|
|
CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2009-11-15 05:45:58 +08:00
|
|
|
&Idents.get("NSConstantString"));
|
2010-02-05 09:33:36 +08:00
|
|
|
CFConstantStringTypeDecl->startDefinition();
|
2009-11-15 05:45:58 +08:00
|
|
|
|
2007-11-19 08:25:30 +08:00
|
|
|
QualType FieldTypes[4];
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-08-17 13:31:46 +08:00
|
|
|
// const int *isa;
|
2009-09-25 03:53:00 +08:00
|
|
|
FieldTypes[0] = getPointerType(IntTy.withConst());
|
2007-11-19 08:25:30 +08:00
|
|
|
// int flags;
|
|
|
|
FieldTypes[1] = IntTy;
|
2007-08-17 13:31:46 +08:00
|
|
|
// const char *str;
|
2009-09-25 03:53:00 +08:00
|
|
|
FieldTypes[2] = getPointerType(CharTy.withConst());
|
2007-08-17 13:31:46 +08:00
|
|
|
// long length;
|
2009-09-09 23:08:12 +08:00
|
|
|
FieldTypes[3] = LongTy;
|
|
|
|
|
2008-12-12 00:49:14 +08:00
|
|
|
// Create fields
|
|
|
|
for (unsigned i = 0; i < 4; ++i) {
|
2009-09-09 23:08:12 +08:00
|
|
|
FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl,
|
2008-12-12 00:49:14 +08:00
|
|
|
SourceLocation(), 0,
|
2009-12-07 10:54:59 +08:00
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
2009-09-09 23:08:12 +08:00
|
|
|
/*BitWidth=*/0,
|
2009-01-20 09:17:11 +08:00
|
|
|
/*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-06-30 10:36:12 +08:00
|
|
|
CFConstantStringTypeDecl->addDecl(Field);
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
|
|
|
|
2010-02-11 09:19:42 +08:00
|
|
|
CFConstantStringTypeDecl->completeDefinition();
|
2007-08-17 13:31:46 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-08-17 13:31:46 +08:00
|
|
|
return getTagDeclType(CFConstantStringTypeDecl);
|
2007-09-11 23:32:40 +08:00
|
|
|
}
|
2007-10-11 09:00:40 +08:00
|
|
|
|
2009-04-24 06:29:11 +08:00
|
|
|
void ASTContext::setCFConstantStringType(QualType T) {
|
2009-07-30 05:53:49 +08:00
|
|
|
const RecordType *Rec = T->getAs<RecordType>();
|
2009-04-24 06:29:11 +08:00
|
|
|
assert(Rec && "Invalid CFConstantStringType");
|
|
|
|
CFConstantStringTypeDecl = Rec->getDecl();
|
|
|
|
}
|
|
|
|
|
2010-04-24 01:41:07 +08:00
|
|
|
// getNSConstantStringType - Return the type used for constant NSStrings.
|
|
|
|
QualType ASTContext::getNSConstantStringType() {
|
|
|
|
if (!NSConstantStringTypeDecl) {
|
|
|
|
NSConstantStringTypeDecl =
|
2010-05-12 05:36:43 +08:00
|
|
|
CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2010-04-24 01:41:07 +08:00
|
|
|
&Idents.get("__builtin_NSString"));
|
|
|
|
NSConstantStringTypeDecl->startDefinition();
|
|
|
|
|
|
|
|
QualType FieldTypes[3];
|
|
|
|
|
|
|
|
// const int *isa;
|
|
|
|
FieldTypes[0] = getPointerType(IntTy.withConst());
|
|
|
|
// const char *str;
|
|
|
|
FieldTypes[1] = getPointerType(CharTy.withConst());
|
|
|
|
// unsigned int length;
|
|
|
|
FieldTypes[2] = UnsignedIntTy;
|
|
|
|
|
|
|
|
// Create fields
|
|
|
|
for (unsigned i = 0; i < 3; ++i) {
|
|
|
|
FieldDecl *Field = FieldDecl::Create(*this, NSConstantStringTypeDecl,
|
|
|
|
SourceLocation(), 0,
|
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
|
|
|
/*BitWidth=*/0,
|
|
|
|
/*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2010-04-24 01:41:07 +08:00
|
|
|
NSConstantStringTypeDecl->addDecl(Field);
|
|
|
|
}
|
|
|
|
|
|
|
|
NSConstantStringTypeDecl->completeDefinition();
|
|
|
|
}
|
|
|
|
|
|
|
|
return getTagDeclType(NSConstantStringTypeDecl);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ASTContext::setNSConstantStringType(QualType T) {
|
|
|
|
const RecordType *Rec = T->getAs<RecordType>();
|
|
|
|
assert(Rec && "Invalid NSConstantStringType");
|
|
|
|
NSConstantStringTypeDecl = Rec->getDecl();
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType ASTContext::getObjCFastEnumerationStateType() {
|
2008-08-31 03:34:46 +08:00
|
|
|
if (!ObjCFastEnumerationStateTypeDecl) {
|
2008-12-12 00:49:14 +08:00
|
|
|
ObjCFastEnumerationStateTypeDecl =
|
2010-05-12 05:36:43 +08:00
|
|
|
CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2009-11-15 05:45:58 +08:00
|
|
|
&Idents.get("__objcFastEnumerationState"));
|
2010-02-05 09:33:36 +08:00
|
|
|
ObjCFastEnumerationStateTypeDecl->startDefinition();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-31 03:34:46 +08:00
|
|
|
QualType FieldTypes[] = {
|
|
|
|
UnsignedLongTy,
|
2009-07-16 02:40:39 +08:00
|
|
|
getPointerType(ObjCIdTypedefType),
|
2008-08-31 03:34:46 +08:00
|
|
|
getPointerType(UnsignedLongTy),
|
|
|
|
getConstantArrayType(UnsignedLongTy,
|
|
|
|
llvm::APInt(32, 5), ArrayType::Normal, 0)
|
|
|
|
};
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-12-12 00:49:14 +08:00
|
|
|
for (size_t i = 0; i < 4; ++i) {
|
2009-09-09 23:08:12 +08:00
|
|
|
FieldDecl *Field = FieldDecl::Create(*this,
|
|
|
|
ObjCFastEnumerationStateTypeDecl,
|
|
|
|
SourceLocation(), 0,
|
2009-12-07 10:54:59 +08:00
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
2009-09-09 23:08:12 +08:00
|
|
|
/*BitWidth=*/0,
|
2009-01-20 09:17:11 +08:00
|
|
|
/*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-06-30 10:36:12 +08:00
|
|
|
ObjCFastEnumerationStateTypeDecl->addDecl(Field);
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-02-11 09:19:42 +08:00
|
|
|
ObjCFastEnumerationStateTypeDecl->completeDefinition();
|
2008-08-31 03:34:46 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-31 03:34:46 +08:00
|
|
|
return getTagDeclType(ObjCFastEnumerationStateTypeDecl);
|
|
|
|
}
|
|
|
|
|
2009-10-20 10:12:22 +08:00
|
|
|
QualType ASTContext::getBlockDescriptorType() {
|
|
|
|
if (BlockDescriptorType)
|
|
|
|
return getTagDeclType(BlockDescriptorType);
|
|
|
|
|
|
|
|
RecordDecl *T;
|
|
|
|
// FIXME: Needs the FlagAppleBlock bit.
|
2010-05-12 05:36:43 +08:00
|
|
|
T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2009-11-15 05:45:58 +08:00
|
|
|
&Idents.get("__block_descriptor"));
|
2010-02-05 09:33:36 +08:00
|
|
|
T->startDefinition();
|
2009-10-20 10:12:22 +08:00
|
|
|
|
|
|
|
QualType FieldTypes[] = {
|
|
|
|
UnsignedLongTy,
|
|
|
|
UnsignedLongTy,
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *FieldNames[] = {
|
|
|
|
"reserved",
|
2009-10-22 08:49:09 +08:00
|
|
|
"Size"
|
2009-10-20 10:12:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
for (size_t i = 0; i < 2; ++i) {
|
|
|
|
FieldDecl *Field = FieldDecl::Create(*this,
|
|
|
|
T,
|
|
|
|
SourceLocation(),
|
|
|
|
&Idents.get(FieldNames[i]),
|
2009-12-07 10:54:59 +08:00
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
2009-10-20 10:12:22 +08:00
|
|
|
/*BitWidth=*/0,
|
|
|
|
/*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-10-20 10:12:22 +08:00
|
|
|
T->addDecl(Field);
|
|
|
|
}
|
|
|
|
|
2010-02-11 09:19:42 +08:00
|
|
|
T->completeDefinition();
|
2009-10-20 10:12:22 +08:00
|
|
|
|
|
|
|
BlockDescriptorType = T;
|
|
|
|
|
|
|
|
return getTagDeclType(BlockDescriptorType);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ASTContext::setBlockDescriptorType(QualType T) {
|
|
|
|
const RecordType *Rec = T->getAs<RecordType>();
|
|
|
|
assert(Rec && "Invalid BlockDescriptorType");
|
|
|
|
BlockDescriptorType = Rec->getDecl();
|
|
|
|
}
|
|
|
|
|
2009-10-22 08:49:09 +08:00
|
|
|
QualType ASTContext::getBlockDescriptorExtendedType() {
|
|
|
|
if (BlockDescriptorExtendedType)
|
|
|
|
return getTagDeclType(BlockDescriptorExtendedType);
|
|
|
|
|
|
|
|
RecordDecl *T;
|
|
|
|
// FIXME: Needs the FlagAppleBlock bit.
|
2010-05-12 05:36:43 +08:00
|
|
|
T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2009-11-15 05:45:58 +08:00
|
|
|
&Idents.get("__block_descriptor_withcopydispose"));
|
2010-02-05 09:33:36 +08:00
|
|
|
T->startDefinition();
|
2009-10-22 08:49:09 +08:00
|
|
|
|
|
|
|
QualType FieldTypes[] = {
|
|
|
|
UnsignedLongTy,
|
|
|
|
UnsignedLongTy,
|
|
|
|
getPointerType(VoidPtrTy),
|
|
|
|
getPointerType(VoidPtrTy)
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *FieldNames[] = {
|
|
|
|
"reserved",
|
|
|
|
"Size",
|
|
|
|
"CopyFuncPtr",
|
|
|
|
"DestroyFuncPtr"
|
|
|
|
};
|
|
|
|
|
|
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
|
|
FieldDecl *Field = FieldDecl::Create(*this,
|
|
|
|
T,
|
|
|
|
SourceLocation(),
|
|
|
|
&Idents.get(FieldNames[i]),
|
2009-12-07 10:54:59 +08:00
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
2009-10-22 08:49:09 +08:00
|
|
|
/*BitWidth=*/0,
|
|
|
|
/*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-10-22 08:49:09 +08:00
|
|
|
T->addDecl(Field);
|
|
|
|
}
|
|
|
|
|
2010-02-11 09:19:42 +08:00
|
|
|
T->completeDefinition();
|
2009-10-22 08:49:09 +08:00
|
|
|
|
|
|
|
BlockDescriptorExtendedType = T;
|
|
|
|
|
|
|
|
return getTagDeclType(BlockDescriptorExtendedType);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ASTContext::setBlockDescriptorExtendedType(QualType T) {
|
|
|
|
const RecordType *Rec = T->getAs<RecordType>();
|
|
|
|
assert(Rec && "Invalid BlockDescriptorType");
|
|
|
|
BlockDescriptorExtendedType = Rec->getDecl();
|
|
|
|
}
|
|
|
|
|
2009-10-22 02:16:27 +08:00
|
|
|
bool ASTContext::BlockRequiresCopying(QualType Ty) {
|
|
|
|
if (Ty->isBlockPointerType())
|
|
|
|
return true;
|
|
|
|
if (isObjCNSObjectType(Ty))
|
|
|
|
return true;
|
|
|
|
if (Ty->isObjCObjectPointerType())
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-08-18 06:39:59 +08:00
|
|
|
QualType ASTContext::BuildByRefType(llvm::StringRef DeclName, QualType Ty) {
|
2009-10-22 02:16:27 +08:00
|
|
|
// type = struct __Block_byref_1_X {
|
2009-10-21 11:49:08 +08:00
|
|
|
// void *__isa;
|
2009-10-22 02:16:27 +08:00
|
|
|
// struct __Block_byref_1_X *__forwarding;
|
2009-10-21 11:49:08 +08:00
|
|
|
// unsigned int __flags;
|
|
|
|
// unsigned int __size;
|
2010-08-22 09:00:03 +08:00
|
|
|
// void *__copy_helper; // as needed
|
|
|
|
// void *__destroy_help // as needed
|
2009-10-22 02:16:27 +08:00
|
|
|
// int X;
|
2009-10-21 11:49:08 +08:00
|
|
|
// } *
|
|
|
|
|
2009-10-22 02:16:27 +08:00
|
|
|
bool HasCopyAndDispose = BlockRequiresCopying(Ty);
|
|
|
|
|
|
|
|
// FIXME: Move up
|
2009-10-24 17:57:09 +08:00
|
|
|
llvm::SmallString<36> Name;
|
|
|
|
llvm::raw_svector_ostream(Name) << "__Block_byref_" <<
|
|
|
|
++UniqueBlockByRefTypeID << '_' << DeclName;
|
2009-10-22 02:16:27 +08:00
|
|
|
RecordDecl *T;
|
2010-05-12 05:36:43 +08:00
|
|
|
T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2009-11-15 05:45:58 +08:00
|
|
|
&Idents.get(Name.str()));
|
2009-10-22 02:16:27 +08:00
|
|
|
T->startDefinition();
|
|
|
|
QualType Int32Ty = IntTy;
|
|
|
|
assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported");
|
|
|
|
QualType FieldTypes[] = {
|
|
|
|
getPointerType(VoidPtrTy),
|
|
|
|
getPointerType(getTagDeclType(T)),
|
|
|
|
Int32Ty,
|
|
|
|
Int32Ty,
|
|
|
|
getPointerType(VoidPtrTy),
|
|
|
|
getPointerType(VoidPtrTy),
|
|
|
|
Ty
|
|
|
|
};
|
|
|
|
|
2010-08-18 06:39:59 +08:00
|
|
|
llvm::StringRef FieldNames[] = {
|
2009-10-22 02:16:27 +08:00
|
|
|
"__isa",
|
|
|
|
"__forwarding",
|
|
|
|
"__flags",
|
|
|
|
"__size",
|
|
|
|
"__copy_helper",
|
|
|
|
"__destroy_helper",
|
|
|
|
DeclName,
|
|
|
|
};
|
|
|
|
|
|
|
|
for (size_t i = 0; i < 7; ++i) {
|
|
|
|
if (!HasCopyAndDispose && i >=4 && i <= 5)
|
|
|
|
continue;
|
|
|
|
FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
|
|
|
|
&Idents.get(FieldNames[i]),
|
2009-12-07 10:54:59 +08:00
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
2009-10-22 02:16:27 +08:00
|
|
|
/*BitWidth=*/0, /*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-10-22 02:16:27 +08:00
|
|
|
T->addDecl(Field);
|
|
|
|
}
|
|
|
|
|
2010-02-11 09:19:42 +08:00
|
|
|
T->completeDefinition();
|
2009-10-22 02:16:27 +08:00
|
|
|
|
|
|
|
return getPointerType(getTagDeclType(T));
|
2009-10-21 11:49:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QualType ASTContext::getBlockParmType(
|
2009-10-22 08:49:09 +08:00
|
|
|
bool BlockHasCopyDispose,
|
2010-05-20 09:18:31 +08:00
|
|
|
llvm::SmallVectorImpl<const Expr *> &Layout) {
|
|
|
|
|
2009-10-20 10:12:22 +08:00
|
|
|
// FIXME: Move up
|
2009-10-24 17:57:09 +08:00
|
|
|
llvm::SmallString<36> Name;
|
|
|
|
llvm::raw_svector_ostream(Name) << "__block_literal_"
|
|
|
|
<< ++UniqueBlockParmTypeID;
|
2009-10-20 10:12:22 +08:00
|
|
|
RecordDecl *T;
|
2010-05-12 05:36:43 +08:00
|
|
|
T = CreateRecordDecl(*this, TTK_Struct, TUDecl, SourceLocation(),
|
2009-11-15 05:45:58 +08:00
|
|
|
&Idents.get(Name.str()));
|
2010-02-05 09:33:36 +08:00
|
|
|
T->startDefinition();
|
2009-10-20 10:12:22 +08:00
|
|
|
QualType FieldTypes[] = {
|
|
|
|
getPointerType(VoidPtrTy),
|
|
|
|
IntTy,
|
|
|
|
IntTy,
|
|
|
|
getPointerType(VoidPtrTy),
|
2009-10-22 08:49:09 +08:00
|
|
|
(BlockHasCopyDispose ?
|
|
|
|
getPointerType(getBlockDescriptorExtendedType()) :
|
|
|
|
getPointerType(getBlockDescriptorType()))
|
2009-10-20 10:12:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
const char *FieldNames[] = {
|
|
|
|
"__isa",
|
|
|
|
"__flags",
|
|
|
|
"__reserved",
|
|
|
|
"__FuncPtr",
|
|
|
|
"__descriptor"
|
|
|
|
};
|
|
|
|
|
|
|
|
for (size_t i = 0; i < 5; ++i) {
|
2009-10-21 11:49:08 +08:00
|
|
|
FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
|
2009-10-20 10:12:22 +08:00
|
|
|
&Idents.get(FieldNames[i]),
|
2009-12-07 10:54:59 +08:00
|
|
|
FieldTypes[i], /*TInfo=*/0,
|
2009-10-21 11:49:08 +08:00
|
|
|
/*BitWidth=*/0, /*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-10-21 11:49:08 +08:00
|
|
|
T->addDecl(Field);
|
|
|
|
}
|
|
|
|
|
2010-05-20 09:18:31 +08:00
|
|
|
for (unsigned i = 0; i < Layout.size(); ++i) {
|
|
|
|
const Expr *E = Layout[i];
|
|
|
|
|
|
|
|
QualType FieldType = E->getType();
|
|
|
|
IdentifierInfo *FieldName = 0;
|
|
|
|
if (isa<CXXThisExpr>(E)) {
|
|
|
|
FieldName = &Idents.get("this");
|
|
|
|
} else if (const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E)) {
|
2009-10-21 11:49:08 +08:00
|
|
|
const ValueDecl *D = BDRE->getDecl();
|
2010-05-20 09:18:31 +08:00
|
|
|
FieldName = D->getIdentifier();
|
|
|
|
if (BDRE->isByRef())
|
2010-08-18 06:39:59 +08:00
|
|
|
FieldType = BuildByRefType(D->getName(), FieldType);
|
2010-05-20 09:18:31 +08:00
|
|
|
} else {
|
|
|
|
// Padding.
|
|
|
|
assert(isa<ConstantArrayType>(FieldType) &&
|
|
|
|
isa<DeclRefExpr>(E) &&
|
|
|
|
!cast<DeclRefExpr>(E)->getDecl()->getDeclName() &&
|
|
|
|
"doesn't match characteristics of padding decl");
|
2009-10-21 11:49:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
|
2010-05-20 09:18:31 +08:00
|
|
|
FieldName, FieldType, /*TInfo=*/0,
|
2009-10-21 11:49:08 +08:00
|
|
|
/*BitWidth=*/0, /*Mutable=*/false);
|
2010-05-01 05:35:41 +08:00
|
|
|
Field->setAccess(AS_public);
|
2009-10-20 10:12:22 +08:00
|
|
|
T->addDecl(Field);
|
|
|
|
}
|
|
|
|
|
2010-02-11 09:19:42 +08:00
|
|
|
T->completeDefinition();
|
2009-10-21 11:49:08 +08:00
|
|
|
|
|
|
|
return getPointerType(getTagDeclType(T));
|
2009-10-20 10:12:22 +08:00
|
|
|
}
|
|
|
|
|
2009-04-24 06:29:11 +08:00
|
|
|
void ASTContext::setObjCFastEnumerationStateType(QualType T) {
|
2009-07-30 05:53:49 +08:00
|
|
|
const RecordType *Rec = T->getAs<RecordType>();
|
2009-04-24 06:29:11 +08:00
|
|
|
assert(Rec && "Invalid ObjCFAstEnumerationStateType");
|
|
|
|
ObjCFastEnumerationStateTypeDecl = Rec->getDecl();
|
|
|
|
}
|
|
|
|
|
2007-10-29 14:33:42 +08:00
|
|
|
// This returns true if a type has been typedefed to BOOL:
|
|
|
|
// typedef <type> BOOL;
|
2007-10-31 04:27:44 +08:00
|
|
|
static bool isTypeTypedefedAsBOOL(QualType T) {
|
2007-10-29 14:33:42 +08:00
|
|
|
if (const TypedefType *TT = dyn_cast<TypedefType>(T))
|
2008-11-24 11:52:59 +08:00
|
|
|
if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
|
|
|
|
return II->isStr("BOOL");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-29 13:01:08 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-01-08 03:49:32 +08:00
|
|
|
/// getObjCEncodingTypeSize returns size of type for objective-c encoding
|
2007-10-30 06:57:28 +08:00
|
|
|
/// purpose.
|
2010-01-12 03:19:56 +08:00
|
|
|
CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) {
|
2010-01-12 01:06:35 +08:00
|
|
|
CharUnits sz = getTypeSizeInChars(type);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-30 06:57:28 +08:00
|
|
|
// Make all integer and enum types at least as large as an int
|
2010-06-16 08:17:44 +08:00
|
|
|
if (sz.isPositive() && type->isIntegralOrEnumerationType())
|
2010-01-12 01:06:35 +08:00
|
|
|
sz = std::max(sz, getTypeSizeInChars(IntTy));
|
2007-10-30 06:57:28 +08:00
|
|
|
// Treat arrays as pointers, since that's how they're passed in.
|
|
|
|
else if (type->isArrayType())
|
2010-01-12 01:06:35 +08:00
|
|
|
sz = getTypeSizeInChars(VoidPtrTy);
|
2010-01-12 03:19:56 +08:00
|
|
|
return sz;
|
2010-01-12 01:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
|
|
|
std::string charUnitsToString(const CharUnits &CU) {
|
|
|
|
return llvm::itostr(CU.getQuantity());
|
2007-10-30 06:57:28 +08:00
|
|
|
}
|
|
|
|
|
2010-04-09 02:06:22 +08:00
|
|
|
/// getObjCEncodingForBlockDecl - Return the encoded type for this block
|
2009-11-18 03:33:30 +08:00
|
|
|
/// declaration.
|
|
|
|
void ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr,
|
|
|
|
std::string& S) {
|
|
|
|
const BlockDecl *Decl = Expr->getBlockDecl();
|
|
|
|
QualType BlockTy =
|
|
|
|
Expr->getType()->getAs<BlockPointerType>()->getPointeeType();
|
|
|
|
// Encode result type.
|
2010-06-05 03:02:56 +08:00
|
|
|
getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), S);
|
2009-11-18 03:33:30 +08:00
|
|
|
// Compute size of all parameters.
|
|
|
|
// Start with computing size of a pointer in number of bytes.
|
|
|
|
// FIXME: There might(should) be a better way of doing this computation!
|
|
|
|
SourceLocation Loc;
|
2010-01-12 01:06:35 +08:00
|
|
|
CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
|
|
|
|
CharUnits ParmOffset = PtrSize;
|
2010-04-09 02:06:22 +08:00
|
|
|
for (BlockDecl::param_const_iterator PI = Decl->param_begin(),
|
2009-11-18 03:33:30 +08:00
|
|
|
E = Decl->param_end(); PI != E; ++PI) {
|
|
|
|
QualType PType = (*PI)->getType();
|
2010-01-12 03:19:56 +08:00
|
|
|
CharUnits sz = getObjCEncodingTypeSize(PType);
|
2010-01-12 01:06:35 +08:00
|
|
|
assert (sz.isPositive() && "BlockExpr - Incomplete param type");
|
2009-11-18 03:33:30 +08:00
|
|
|
ParmOffset += sz;
|
|
|
|
}
|
|
|
|
// Size of the argument frame
|
2010-01-12 01:06:35 +08:00
|
|
|
S += charUnitsToString(ParmOffset);
|
2009-11-18 03:33:30 +08:00
|
|
|
// Block pointer and offset.
|
|
|
|
S += "@?0";
|
|
|
|
ParmOffset = PtrSize;
|
|
|
|
|
|
|
|
// Argument types.
|
|
|
|
ParmOffset = PtrSize;
|
|
|
|
for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E =
|
|
|
|
Decl->param_end(); PI != E; ++PI) {
|
|
|
|
ParmVarDecl *PVDecl = *PI;
|
|
|
|
QualType PType = PVDecl->getOriginalType();
|
|
|
|
if (const ArrayType *AT =
|
|
|
|
dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
|
|
|
|
// Use array's original type only if it has known number of
|
|
|
|
// elements.
|
|
|
|
if (!isa<ConstantArrayType>(AT))
|
|
|
|
PType = PVDecl->getType();
|
|
|
|
} else if (PType->isFunctionType())
|
|
|
|
PType = PVDecl->getType();
|
|
|
|
getObjCEncodingForType(PType, S);
|
2010-01-12 01:06:35 +08:00
|
|
|
S += charUnitsToString(ParmOffset);
|
2010-01-12 03:19:56 +08:00
|
|
|
ParmOffset += getObjCEncodingTypeSize(PType);
|
2009-11-18 03:33:30 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-08 03:49:32 +08:00
|
|
|
/// getObjCEncodingForMethodDecl - Return the encoded type for this method
|
2007-10-30 06:57:28 +08:00
|
|
|
/// declaration.
|
2009-09-09 23:08:12 +08:00
|
|
|
void ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
|
2008-11-19 15:24:05 +08:00
|
|
|
std::string& S) {
|
2008-08-28 12:38:10 +08:00
|
|
|
// FIXME: This is not very efficient.
|
2007-11-02 01:18:37 +08:00
|
|
|
// Encode type qualifer, 'in', 'inout', etc. for the return type.
|
2008-01-08 03:49:32 +08:00
|
|
|
getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S);
|
2007-10-30 06:57:28 +08:00
|
|
|
// Encode result type.
|
2008-10-18 04:21:44 +08:00
|
|
|
getObjCEncodingForType(Decl->getResultType(), S);
|
2007-10-30 06:57:28 +08:00
|
|
|
// Compute size of all parameters.
|
|
|
|
// Start with computing size of a pointer in number of bytes.
|
|
|
|
// FIXME: There might(should) be a better way of doing this computation!
|
|
|
|
SourceLocation Loc;
|
2010-01-12 01:06:35 +08:00
|
|
|
CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
|
2007-10-30 06:57:28 +08:00
|
|
|
// The first two arguments (self and _cmd) are pointers; account for
|
|
|
|
// their size.
|
2010-01-12 01:06:35 +08:00
|
|
|
CharUnits ParmOffset = 2 * PtrSize;
|
2009-02-21 02:43:26 +08:00
|
|
|
for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
|
2010-04-09 05:29:11 +08:00
|
|
|
E = Decl->sel_param_end(); PI != E; ++PI) {
|
2009-02-21 02:43:26 +08:00
|
|
|
QualType PType = (*PI)->getType();
|
2010-01-12 03:19:56 +08:00
|
|
|
CharUnits sz = getObjCEncodingTypeSize(PType);
|
2010-01-12 01:06:35 +08:00
|
|
|
assert (sz.isPositive() &&
|
|
|
|
"getObjCEncodingForMethodDecl - Incomplete param type");
|
2007-10-30 06:57:28 +08:00
|
|
|
ParmOffset += sz;
|
|
|
|
}
|
2010-01-12 01:06:35 +08:00
|
|
|
S += charUnitsToString(ParmOffset);
|
2007-10-30 06:57:28 +08:00
|
|
|
S += "@0:";
|
2010-01-12 01:06:35 +08:00
|
|
|
S += charUnitsToString(PtrSize);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-30 06:57:28 +08:00
|
|
|
// Argument types.
|
|
|
|
ParmOffset = 2 * PtrSize;
|
2009-02-21 02:43:26 +08:00
|
|
|
for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
|
2010-04-09 05:29:11 +08:00
|
|
|
E = Decl->sel_param_end(); PI != E; ++PI) {
|
2009-02-21 02:43:26 +08:00
|
|
|
ParmVarDecl *PVDecl = *PI;
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType PType = PVDecl->getOriginalType();
|
2008-12-21 07:29:59 +08:00
|
|
|
if (const ArrayType *AT =
|
2009-04-14 08:03:58 +08:00
|
|
|
dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
|
|
|
|
// Use array's original type only if it has known number of
|
|
|
|
// elements.
|
2009-04-14 08:40:09 +08:00
|
|
|
if (!isa<ConstantArrayType>(AT))
|
2009-04-14 08:03:58 +08:00
|
|
|
PType = PVDecl->getType();
|
|
|
|
} else if (PType->isFunctionType())
|
|
|
|
PType = PVDecl->getType();
|
2007-11-02 01:18:37 +08:00
|
|
|
// Process argument qualifiers for user supplied arguments; such as,
|
2007-10-30 06:57:28 +08:00
|
|
|
// 'in', 'inout', etc.
|
2008-12-21 07:29:59 +08:00
|
|
|
getObjCEncodingForTypeQualifier(PVDecl->getObjCDeclQualifier(), S);
|
2008-10-18 04:21:44 +08:00
|
|
|
getObjCEncodingForType(PType, S);
|
2010-01-12 01:06:35 +08:00
|
|
|
S += charUnitsToString(ParmOffset);
|
2010-01-12 03:19:56 +08:00
|
|
|
ParmOffset += getObjCEncodingTypeSize(PType);
|
2007-10-30 06:57:28 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-28 12:38:10 +08:00
|
|
|
/// getObjCEncodingForPropertyDecl - Return the encoded type for this
|
2009-01-21 04:04:12 +08:00
|
|
|
/// property declaration. If non-NULL, Container must be either an
|
2008-08-28 12:38:10 +08:00
|
|
|
/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
|
|
|
|
/// NULL when getting encodings for protocol properties.
|
2009-09-09 23:08:12 +08:00
|
|
|
/// Property attributes are stored as a comma-delimited C string. The simple
|
|
|
|
/// attributes readonly and bycopy are encoded as single characters. The
|
|
|
|
/// parametrized attributes, getter=name, setter=name, and ivar=name, are
|
|
|
|
/// encoded as single characters, followed by an identifier. Property types
|
|
|
|
/// are also encoded as a parametrized attribute. The characters used to encode
|
2009-01-21 04:04:12 +08:00
|
|
|
/// these attributes are defined by the following enumeration:
|
|
|
|
/// @code
|
|
|
|
/// enum PropertyAttributes {
|
|
|
|
/// kPropertyReadOnly = 'R', // property is read-only.
|
|
|
|
/// kPropertyBycopy = 'C', // property is a copy of the value last assigned
|
|
|
|
/// kPropertyByref = '&', // property is a reference to the value last assigned
|
|
|
|
/// kPropertyDynamic = 'D', // property is dynamic
|
|
|
|
/// kPropertyGetter = 'G', // followed by getter selector name
|
|
|
|
/// kPropertySetter = 'S', // followed by setter selector name
|
|
|
|
/// kPropertyInstanceVariable = 'V' // followed by instance variable name
|
|
|
|
/// kPropertyType = 't' // followed by old-style type encoding.
|
|
|
|
/// kPropertyWeak = 'W' // 'weak' property
|
|
|
|
/// kPropertyStrong = 'P' // property GC'able
|
|
|
|
/// kPropertyNonAtomic = 'N' // property non-atomic
|
|
|
|
/// };
|
|
|
|
/// @endcode
|
2009-09-09 23:08:12 +08:00
|
|
|
void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
|
2008-08-28 12:38:10 +08:00
|
|
|
const Decl *Container,
|
2008-11-19 15:24:05 +08:00
|
|
|
std::string& S) {
|
2008-08-28 12:38:10 +08:00
|
|
|
// Collect information from the property implementation decl(s).
|
|
|
|
bool Dynamic = false;
|
|
|
|
ObjCPropertyImplDecl *SynthesizePID = 0;
|
|
|
|
|
|
|
|
// FIXME: Duplicated code due to poor abstraction.
|
|
|
|
if (Container) {
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const ObjCCategoryImplDecl *CID =
|
2008-08-28 12:38:10 +08:00
|
|
|
dyn_cast<ObjCCategoryImplDecl>(Container)) {
|
|
|
|
for (ObjCCategoryImplDecl::propimpl_iterator
|
2009-06-30 10:36:12 +08:00
|
|
|
i = CID->propimpl_begin(), e = CID->propimpl_end();
|
2009-04-23 09:02:12 +08:00
|
|
|
i != e; ++i) {
|
2008-08-28 12:38:10 +08:00
|
|
|
ObjCPropertyImplDecl *PID = *i;
|
|
|
|
if (PID->getPropertyDecl() == PD) {
|
|
|
|
if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
|
|
|
|
Dynamic = true;
|
|
|
|
} else {
|
|
|
|
SynthesizePID = PID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2008-10-06 01:34:18 +08:00
|
|
|
const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container);
|
2008-08-28 12:38:10 +08:00
|
|
|
for (ObjCCategoryImplDecl::propimpl_iterator
|
2009-06-30 10:36:12 +08:00
|
|
|
i = OID->propimpl_begin(), e = OID->propimpl_end();
|
2009-04-23 09:02:12 +08:00
|
|
|
i != e; ++i) {
|
2008-08-28 12:38:10 +08:00
|
|
|
ObjCPropertyImplDecl *PID = *i;
|
|
|
|
if (PID->getPropertyDecl() == PD) {
|
|
|
|
if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
|
|
|
|
Dynamic = true;
|
|
|
|
} else {
|
|
|
|
SynthesizePID = PID;
|
|
|
|
}
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
2008-08-28 12:38:10 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: This is not very efficient.
|
|
|
|
S = "T";
|
|
|
|
|
|
|
|
// Encode result type.
|
2009-01-21 03:14:18 +08:00
|
|
|
// GCC has some special rules regarding encoding of properties which
|
|
|
|
// closely resembles encoding of ivars.
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0,
|
2009-01-21 03:14:18 +08:00
|
|
|
true /* outermost type */,
|
|
|
|
true /* encoding for property */);
|
2008-08-28 12:38:10 +08:00
|
|
|
|
|
|
|
if (PD->isReadOnly()) {
|
|
|
|
S += ",R";
|
|
|
|
} else {
|
|
|
|
switch (PD->getSetterKind()) {
|
|
|
|
case ObjCPropertyDecl::Assign: break;
|
|
|
|
case ObjCPropertyDecl::Copy: S += ",C"; break;
|
2009-09-09 23:08:12 +08:00
|
|
|
case ObjCPropertyDecl::Retain: S += ",&"; break;
|
2008-08-28 12:38:10 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// It really isn't clear at all what this means, since properties
|
|
|
|
// are "dynamic by default".
|
|
|
|
if (Dynamic)
|
|
|
|
S += ",D";
|
|
|
|
|
2009-01-21 03:14:18 +08:00
|
|
|
if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
|
|
|
|
S += ",N";
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-28 12:38:10 +08:00
|
|
|
if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
|
|
|
|
S += ",G";
|
2008-11-24 11:33:13 +08:00
|
|
|
S += PD->getGetterName().getAsString();
|
2008-08-28 12:38:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
|
|
|
|
S += ",S";
|
2008-11-24 11:33:13 +08:00
|
|
|
S += PD->getSetterName().getAsString();
|
2008-08-28 12:38:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (SynthesizePID) {
|
|
|
|
const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
|
|
|
|
S += ",V";
|
2008-11-24 12:00:27 +08:00
|
|
|
S += OID->getNameAsString();
|
2008-08-28 12:38:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: OBJCGC: weak & strong
|
|
|
|
}
|
|
|
|
|
2008-12-24 03:56:47 +08:00
|
|
|
/// getLegacyIntegralTypeEncoding -
|
2009-09-09 23:08:12 +08:00
|
|
|
/// Another legacy compatibility encoding: 32-bit longs are encoded as
|
|
|
|
/// 'l' or 'L' , but not always. For typedefs, we need to use
|
2008-12-24 03:56:47 +08:00
|
|
|
/// 'i' or 'I' instead if encoding a struct field, or a pointer!
|
|
|
|
///
|
|
|
|
void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
|
2009-07-23 02:58:19 +08:00
|
|
|
if (isa<TypedefType>(PointeeTy.getTypePtr())) {
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) {
|
2009-02-12 07:59:18 +08:00
|
|
|
if (BT->getKind() == BuiltinType::ULong &&
|
|
|
|
((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
|
2008-12-24 03:56:47 +08:00
|
|
|
PointeeTy = UnsignedIntTy;
|
2009-09-09 23:08:12 +08:00
|
|
|
else
|
2009-02-12 07:59:18 +08:00
|
|
|
if (BT->getKind() == BuiltinType::Long &&
|
|
|
|
((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
|
2008-12-24 03:56:47 +08:00
|
|
|
PointeeTy = IntTy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-23 06:44:46 +08:00
|
|
|
void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
|
2009-04-20 14:37:24 +08:00
|
|
|
const FieldDecl *Field) {
|
2008-10-17 15:30:50 +08:00
|
|
|
// We follow the behavior of gcc, expanding structures which are
|
|
|
|
// directly pointed to, and expanding embedded structures. Note that
|
|
|
|
// these rules are sufficient to prevent recursive encoding of the
|
|
|
|
// same type.
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(T, S, true, true, Field,
|
2008-12-23 07:22:27 +08:00
|
|
|
true /* outermost type */);
|
2008-10-17 15:30:50 +08:00
|
|
|
}
|
|
|
|
|
2010-06-04 09:10:52 +08:00
|
|
|
static char ObjCEncodingForPrimitiveKind(const ASTContext *C, QualType T) {
|
|
|
|
switch (T->getAs<BuiltinType>()->getKind()) {
|
|
|
|
default: assert(0 && "Unhandled builtin type kind");
|
|
|
|
case BuiltinType::Void: return 'v';
|
|
|
|
case BuiltinType::Bool: return 'B';
|
|
|
|
case BuiltinType::Char_U:
|
|
|
|
case BuiltinType::UChar: return 'C';
|
|
|
|
case BuiltinType::UShort: return 'S';
|
|
|
|
case BuiltinType::UInt: return 'I';
|
|
|
|
case BuiltinType::ULong:
|
|
|
|
return
|
|
|
|
(const_cast<ASTContext *>(C))->getIntWidth(T) == 32 ? 'L' : 'Q';
|
|
|
|
case BuiltinType::UInt128: return 'T';
|
|
|
|
case BuiltinType::ULongLong: return 'Q';
|
|
|
|
case BuiltinType::Char_S:
|
|
|
|
case BuiltinType::SChar: return 'c';
|
|
|
|
case BuiltinType::Short: return 's';
|
2010-06-11 18:11:05 +08:00
|
|
|
case BuiltinType::WChar:
|
2010-06-04 09:10:52 +08:00
|
|
|
case BuiltinType::Int: return 'i';
|
|
|
|
case BuiltinType::Long:
|
|
|
|
return
|
|
|
|
(const_cast<ASTContext *>(C))->getIntWidth(T) == 32 ? 'l' : 'q';
|
|
|
|
case BuiltinType::LongLong: return 'q';
|
|
|
|
case BuiltinType::Int128: return 't';
|
|
|
|
case BuiltinType::Float: return 'f';
|
|
|
|
case BuiltinType::Double: return 'd';
|
2010-10-12 05:13:48 +08:00
|
|
|
case BuiltinType::LongDouble: return 'D';
|
2010-06-04 09:10:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
static void EncodeBitField(const ASTContext *Context, std::string& S,
|
2010-06-04 09:10:52 +08:00
|
|
|
QualType T, const FieldDecl *FD) {
|
2009-01-13 09:18:13 +08:00
|
|
|
const Expr *E = FD->getBitWidth();
|
|
|
|
assert(E && "bitfield width not there - getObjCEncodingForTypeImpl");
|
|
|
|
ASTContext *Ctx = const_cast<ASTContext*>(Context);
|
|
|
|
S += 'b';
|
2010-06-04 09:10:52 +08:00
|
|
|
// The NeXT runtime encodes bit fields as b followed by the number of bits.
|
|
|
|
// The GNU runtime requires more information; bitfields are encoded as b,
|
|
|
|
// then the offset (in bits) of the first element, then the type of the
|
|
|
|
// bitfield, then the size in bits. For example, in this structure:
|
|
|
|
//
|
|
|
|
// struct
|
|
|
|
// {
|
|
|
|
// int integer;
|
|
|
|
// int flags:2;
|
|
|
|
// };
|
|
|
|
// On a 32-bit system, the encoding for flags would be b2 for the NeXT
|
|
|
|
// runtime, but b32i2 for the GNU runtime. The reason for this extra
|
|
|
|
// information is not especially sensible, but we're stuck with it for
|
|
|
|
// compatibility with GCC, although providing it breaks anything that
|
|
|
|
// actually uses runtime introspection and wants to work on both runtimes...
|
|
|
|
if (!Ctx->getLangOptions().NeXTRuntime) {
|
|
|
|
const RecordDecl *RD = FD->getParent();
|
|
|
|
const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
|
|
|
|
// FIXME: This same linear search is also used in ExprConstant - it might
|
|
|
|
// be better if the FieldDecl stored its offset. We'd be increasing the
|
|
|
|
// size of the object slightly, but saving some time every time it is used.
|
|
|
|
unsigned i = 0;
|
|
|
|
for (RecordDecl::field_iterator Field = RD->field_begin(),
|
|
|
|
FieldEnd = RD->field_end();
|
|
|
|
Field != FieldEnd; (void)++Field, ++i) {
|
|
|
|
if (*Field == FD)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
S += llvm::utostr(RL.getFieldOffset(i));
|
|
|
|
S += ObjCEncodingForPrimitiveKind(Context, T);
|
|
|
|
}
|
|
|
|
unsigned N = E->EvaluateAsInt(*Ctx).getZExtValue();
|
2009-01-13 09:18:13 +08:00
|
|
|
S += llvm::utostr(N);
|
|
|
|
}
|
|
|
|
|
2009-10-19 05:17:35 +08:00
|
|
|
// FIXME: Use SmallString for accumulating string.
|
2008-10-17 15:30:50 +08:00
|
|
|
void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
|
|
|
|
bool ExpandPointedToStructures,
|
|
|
|
bool ExpandStructures,
|
2009-04-20 14:37:24 +08:00
|
|
|
const FieldDecl *FD,
|
2009-01-21 03:14:18 +08:00
|
|
|
bool OutermostType,
|
2009-04-10 05:40:53 +08:00
|
|
|
bool EncodingProperty) {
|
2010-06-04 09:10:52 +08:00
|
|
|
if (T->getAs<BuiltinType>()) {
|
2009-07-13 08:10:46 +08:00
|
|
|
if (FD && FD->isBitField())
|
2010-06-04 09:10:52 +08:00
|
|
|
return EncodeBitField(this, S, T, FD);
|
|
|
|
S += ObjCEncodingForPrimitiveKind(this, T);
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const ComplexType *CT = T->getAs<ComplexType>()) {
|
2009-04-10 05:55:45 +08:00
|
|
|
S += 'j';
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false,
|
2009-04-10 05:55:45 +08:00
|
|
|
false);
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-11-24 04:40:50 +08:00
|
|
|
|
2010-04-14 07:45:47 +08:00
|
|
|
// encoding for pointer or r3eference types.
|
|
|
|
QualType PointeeTy;
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const PointerType *PT = T->getAs<PointerType>()) {
|
2009-12-01 02:43:52 +08:00
|
|
|
if (PT->isObjCSelType()) {
|
|
|
|
S += ':';
|
|
|
|
return;
|
|
|
|
}
|
2010-04-14 07:45:47 +08:00
|
|
|
PointeeTy = PT->getPointeeType();
|
|
|
|
}
|
|
|
|
else if (const ReferenceType *RT = T->getAs<ReferenceType>())
|
|
|
|
PointeeTy = RT->getPointeeType();
|
|
|
|
if (!PointeeTy.isNull()) {
|
2008-12-24 03:56:47 +08:00
|
|
|
bool isReadOnly = false;
|
|
|
|
// For historical/compatibility reasons, the read-only qualifier of the
|
|
|
|
// pointee gets emitted _before_ the '^'. The read-only qualifier of
|
|
|
|
// the pointer itself gets ignored, _unless_ we are looking at a typedef!
|
2009-09-09 23:08:12 +08:00
|
|
|
// Also, do not emit the 'r' for anything but the outermost type!
|
2009-07-23 02:58:19 +08:00
|
|
|
if (isa<TypedefType>(T.getTypePtr())) {
|
2008-12-24 03:56:47 +08:00
|
|
|
if (OutermostType && T.isConstQualified()) {
|
|
|
|
isReadOnly = true;
|
|
|
|
S += 'r';
|
|
|
|
}
|
2009-07-31 10:02:20 +08:00
|
|
|
} else if (OutermostType) {
|
2008-12-24 03:56:47 +08:00
|
|
|
QualType P = PointeeTy;
|
2009-07-30 05:53:49 +08:00
|
|
|
while (P->getAs<PointerType>())
|
|
|
|
P = P->getAs<PointerType>()->getPointeeType();
|
2008-12-24 03:56:47 +08:00
|
|
|
if (P.isConstQualified()) {
|
|
|
|
isReadOnly = true;
|
|
|
|
S += 'r';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (isReadOnly) {
|
|
|
|
// Another legacy compatibility encoding. Some ObjC qualifier and type
|
|
|
|
// combinations need to be rearranged.
|
|
|
|
// Rewrite "in const" from "nr" to "rn"
|
2010-04-28 01:12:11 +08:00
|
|
|
if (llvm::StringRef(S).endswith("nr"))
|
|
|
|
S.replace(S.end()-2, S.end(), "rn");
|
2008-12-24 03:56:47 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-29 13:01:08 +08:00
|
|
|
if (PointeeTy->isCharType()) {
|
|
|
|
// char pointer types should be encoded as '*' unless it is a
|
|
|
|
// type that has been typedef'd to 'BOOL'.
|
2007-10-29 14:33:42 +08:00
|
|
|
if (!isTypeTypedefedAsBOOL(PointeeTy)) {
|
2007-10-29 13:01:08 +08:00
|
|
|
S += '*';
|
|
|
|
return;
|
|
|
|
}
|
2009-07-30 05:53:49 +08:00
|
|
|
} else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) {
|
2009-07-23 01:14:51 +08:00
|
|
|
// GCC binary compat: Need to convert "struct objc_class *" to "#".
|
|
|
|
if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
|
|
|
|
S += '#';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// GCC binary compat: Need to convert "struct objc_object *" to "@".
|
|
|
|
if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
|
|
|
|
S += '@';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// fall through...
|
2007-10-29 13:01:08 +08:00
|
|
|
}
|
|
|
|
S += '^';
|
2008-12-24 03:56:47 +08:00
|
|
|
getLegacyIntegralTypeEncoding(PointeeTy);
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
|
2008-12-20 07:34:38 +08:00
|
|
|
NULL);
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2010-04-14 07:45:47 +08:00
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
if (const ArrayType *AT =
|
|
|
|
// Ignore type qualifiers etc.
|
|
|
|
dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) {
|
2009-02-22 09:38:57 +08:00
|
|
|
if (isa<IncompleteArrayType>(AT)) {
|
|
|
|
// Incomplete arrays are encoded as a pointer to the array element.
|
|
|
|
S += '^';
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(AT->getElementType(), S,
|
2009-02-22 09:38:57 +08:00
|
|
|
false, ExpandStructures, FD);
|
|
|
|
} else {
|
|
|
|
S += '[';
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-02-22 09:38:57 +08:00
|
|
|
if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
|
|
|
|
S += llvm::utostr(CAT->getSize().getZExtValue());
|
|
|
|
else {
|
|
|
|
//Variable length arrays are encoded as a regular array with 0 elements.
|
|
|
|
assert(isa<VariableArrayType>(AT) && "Unknown array type!");
|
|
|
|
S += '0';
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
getObjCEncodingForTypeImpl(AT->getElementType(), S,
|
2009-02-22 09:38:57 +08:00
|
|
|
false, ExpandStructures, FD);
|
|
|
|
S += ']';
|
|
|
|
}
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-22 07:43:11 +08:00
|
|
|
if (T->getAs<FunctionType>()) {
|
2007-10-30 08:06:20 +08:00
|
|
|
S += '?';
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const RecordType *RTy = T->getAs<RecordType>()) {
|
2008-10-17 15:30:50 +08:00
|
|
|
RecordDecl *RDecl = RTy->getDecl();
|
2008-10-18 00:17:37 +08:00
|
|
|
S += RDecl->isUnion() ? '(' : '{';
|
2008-10-17 14:22:57 +08:00
|
|
|
// Anonymous structures print as '?'
|
|
|
|
if (const IdentifierInfo *II = RDecl->getIdentifier()) {
|
|
|
|
S += II->getName();
|
2010-05-07 08:28:49 +08:00
|
|
|
if (ClassTemplateSpecializationDecl *Spec
|
|
|
|
= dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
|
|
|
|
const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
|
|
|
|
std::string TemplateArgsStr
|
|
|
|
= TemplateSpecializationType::PrintTemplateArgumentList(
|
|
|
|
TemplateArgs.getFlatArgumentList(),
|
|
|
|
TemplateArgs.flat_size(),
|
|
|
|
(*this).PrintingPolicy);
|
|
|
|
|
|
|
|
S += TemplateArgsStr;
|
|
|
|
}
|
2008-10-17 14:22:57 +08:00
|
|
|
} else {
|
|
|
|
S += '?';
|
|
|
|
}
|
2008-10-18 04:21:44 +08:00
|
|
|
if (ExpandStructures) {
|
2008-01-23 06:44:46 +08:00
|
|
|
S += '=';
|
2009-06-30 10:36:12 +08:00
|
|
|
for (RecordDecl::field_iterator Field = RDecl->field_begin(),
|
|
|
|
FieldEnd = RDecl->field_end();
|
2008-12-12 00:49:14 +08:00
|
|
|
Field != FieldEnd; ++Field) {
|
2008-12-20 07:34:38 +08:00
|
|
|
if (FD) {
|
2008-10-18 00:17:37 +08:00
|
|
|
S += '"';
|
2008-12-12 00:49:14 +08:00
|
|
|
S += Field->getNameAsString();
|
2008-10-18 00:17:37 +08:00
|
|
|
S += '"';
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-10-18 00:17:37 +08:00
|
|
|
// Special case bit-fields.
|
2008-12-20 07:34:38 +08:00
|
|
|
if (Field->isBitField()) {
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
|
2008-12-20 07:34:38 +08:00
|
|
|
(*Field));
|
2008-10-18 00:17:37 +08:00
|
|
|
} else {
|
2008-12-24 03:56:47 +08:00
|
|
|
QualType qt = Field->getType();
|
|
|
|
getLegacyIntegralTypeEncoding(qt);
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(qt, S, false, true,
|
2008-12-20 07:34:38 +08:00
|
|
|
FD);
|
2008-10-18 00:17:37 +08:00
|
|
|
}
|
2008-01-23 06:44:46 +08:00
|
|
|
}
|
2007-11-14 07:21:38 +08:00
|
|
|
}
|
2008-10-18 00:17:37 +08:00
|
|
|
S += RDecl->isUnion() ? ')' : '}';
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2010-10-08 05:25:25 +08:00
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
if (T->isEnumeralType()) {
|
2009-01-13 09:18:13 +08:00
|
|
|
if (FD && FD->isBitField())
|
2010-06-04 09:10:52 +08:00
|
|
|
EncodeBitField(this, S, T, FD);
|
2009-01-13 09:18:13 +08:00
|
|
|
else
|
|
|
|
S += 'i';
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
if (T->isBlockPointerType()) {
|
2009-02-03 02:24:29 +08:00
|
|
|
S += "@?"; // Unlike a pointer-to-function, which is "^?".
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// Ignore protocol qualifiers when mangling at this level.
|
|
|
|
if (const ObjCObjectType *OT = T->getAs<ObjCObjectType>())
|
|
|
|
T = OT->getBaseType();
|
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) {
|
2008-12-20 07:34:38 +08:00
|
|
|
// @encode(class_name)
|
2009-09-25 03:53:00 +08:00
|
|
|
ObjCInterfaceDecl *OI = OIT->getDecl();
|
2008-12-20 07:34:38 +08:00
|
|
|
S += '{';
|
|
|
|
const IdentifierInfo *II = OI->getIdentifier();
|
|
|
|
S += II->getName();
|
|
|
|
S += '=';
|
2010-08-21 05:21:08 +08:00
|
|
|
llvm::SmallVector<ObjCIvarDecl*, 32> Ivars;
|
|
|
|
DeepCollectObjCIvars(OI, true, Ivars);
|
|
|
|
for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
|
|
|
|
FieldDecl *Field = cast<FieldDecl>(Ivars[i]);
|
|
|
|
if (Field->isBitField())
|
|
|
|
getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field);
|
2008-12-20 07:34:38 +08:00
|
|
|
else
|
2010-08-21 05:21:08 +08:00
|
|
|
getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD);
|
2008-12-20 07:34:38 +08:00
|
|
|
}
|
|
|
|
S += '}';
|
2009-07-13 08:10:46 +08:00
|
|
|
return;
|
2008-12-20 07:34:38 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) {
|
2009-07-11 07:34:53 +08:00
|
|
|
if (OPT->isObjCIdType()) {
|
|
|
|
S += '@';
|
|
|
|
return;
|
2009-07-13 08:10:46 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-10-29 06:03:49 +08:00
|
|
|
if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
|
|
|
|
// FIXME: Consider if we need to output qualifiers for 'Class<p>'.
|
|
|
|
// Since this is a binary compatibility issue, need to consult with runtime
|
|
|
|
// folks. Fortunately, this is a *very* obsure construct.
|
2009-07-11 07:34:53 +08:00
|
|
|
S += '#';
|
|
|
|
return;
|
2009-07-13 08:10:46 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
if (OPT->isObjCQualifiedIdType()) {
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(getObjCIdType(), S,
|
2009-07-11 07:34:53 +08:00
|
|
|
ExpandPointedToStructures,
|
|
|
|
ExpandStructures, FD);
|
|
|
|
if (FD || EncodingProperty) {
|
|
|
|
// Note that we do extended encoding of protocol qualifer list
|
|
|
|
// Only when doing ivar or property encoding.
|
|
|
|
S += '"';
|
2009-07-21 01:56:53 +08:00
|
|
|
for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
|
|
|
|
E = OPT->qual_end(); I != E; ++I) {
|
2009-07-11 07:34:53 +08:00
|
|
|
S += '<';
|
|
|
|
S += (*I)->getNameAsString();
|
|
|
|
S += '>';
|
|
|
|
}
|
|
|
|
S += '"';
|
|
|
|
}
|
|
|
|
return;
|
2009-07-13 08:10:46 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
QualType PointeeTy = OPT->getPointeeType();
|
|
|
|
if (!EncodingProperty &&
|
|
|
|
isa<TypedefType>(PointeeTy.getTypePtr())) {
|
|
|
|
// Another historical/compatibility reason.
|
2009-09-09 23:08:12 +08:00
|
|
|
// We encode the underlying type which comes out as
|
2009-07-13 08:10:46 +08:00
|
|
|
// {...};
|
|
|
|
S += '^';
|
2009-09-09 23:08:12 +08:00
|
|
|
getObjCEncodingForTypeImpl(PointeeTy, S,
|
|
|
|
false, ExpandPointedToStructures,
|
2009-07-13 08:10:46 +08:00
|
|
|
NULL);
|
2009-07-11 07:34:53 +08:00
|
|
|
return;
|
|
|
|
}
|
2009-07-13 08:10:46 +08:00
|
|
|
|
|
|
|
S += '@';
|
2009-10-29 06:03:49 +08:00
|
|
|
if (OPT->getInterfaceDecl() && (FD || EncodingProperty)) {
|
2009-07-13 08:10:46 +08:00
|
|
|
S += '"';
|
2009-10-29 06:03:49 +08:00
|
|
|
S += OPT->getInterfaceDecl()->getIdentifier()->getName();
|
2009-07-21 01:56:53 +08:00
|
|
|
for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
|
|
|
|
E = OPT->qual_end(); I != E; ++I) {
|
2009-07-13 08:10:46 +08:00
|
|
|
S += '<';
|
|
|
|
S += (*I)->getNameAsString();
|
|
|
|
S += '>';
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
2009-07-13 08:10:46 +08:00
|
|
|
S += '"';
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-05-18 07:56:34 +08:00
|
|
|
// gcc just blithely ignores member pointers.
|
|
|
|
// TODO: maybe there should be a mangling for these
|
|
|
|
if (T->getAs<MemberPointerType>())
|
|
|
|
return;
|
2010-10-08 05:25:25 +08:00
|
|
|
|
|
|
|
if (T->isVectorType()) {
|
|
|
|
// This matches gcc's encoding, even though technically it is
|
|
|
|
// insufficient.
|
|
|
|
// FIXME. We should do a better job than gcc.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
assert(0 && "@encode for type not implemented!");
|
2007-10-29 13:01:08 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
|
2007-11-02 01:18:37 +08:00
|
|
|
std::string& S) const {
|
|
|
|
if (QT & Decl::OBJC_TQ_In)
|
|
|
|
S += 'n';
|
|
|
|
if (QT & Decl::OBJC_TQ_Inout)
|
|
|
|
S += 'N';
|
|
|
|
if (QT & Decl::OBJC_TQ_Out)
|
|
|
|
S += 'o';
|
|
|
|
if (QT & Decl::OBJC_TQ_Bycopy)
|
|
|
|
S += 'O';
|
|
|
|
if (QT & Decl::OBJC_TQ_Byref)
|
|
|
|
S += 'R';
|
|
|
|
if (QT & Decl::OBJC_TQ_Oneway)
|
|
|
|
S += 'V';
|
|
|
|
}
|
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
void ASTContext::setBuiltinVaListType(QualType T) {
|
2007-10-11 09:00:40 +08:00
|
|
|
assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2007-10-11 09:00:40 +08:00
|
|
|
BuiltinVaListType = T;
|
|
|
|
}
|
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
void ASTContext::setObjCIdType(QualType T) {
|
2009-07-16 02:40:39 +08:00
|
|
|
ObjCIdTypedefType = T;
|
2007-10-15 22:41:52 +08:00
|
|
|
}
|
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
void ASTContext::setObjCSelType(QualType T) {
|
2009-11-22 03:53:08 +08:00
|
|
|
ObjCSelTypedefType = T;
|
2007-10-17 04:40:23 +08:00
|
|
|
}
|
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
void ASTContext::setObjCProtoType(QualType QT) {
|
2008-01-08 03:49:32 +08:00
|
|
|
ObjCProtoType = QT;
|
2007-10-18 00:58:11 +08:00
|
|
|
}
|
|
|
|
|
2009-07-13 08:10:46 +08:00
|
|
|
void ASTContext::setObjCClassType(QualType T) {
|
2009-07-16 02:40:39 +08:00
|
|
|
ObjCClassTypedefType = T;
|
2007-10-31 10:53:19 +08:00
|
|
|
}
|
|
|
|
|
2008-01-08 03:49:32 +08:00
|
|
|
void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(ObjCConstantStringType.isNull() &&
|
2007-10-16 07:35:17 +08:00
|
|
|
"'NSConstantString' type already set!");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-01-08 03:49:32 +08:00
|
|
|
ObjCConstantStringType = getObjCInterfaceType(Decl);
|
2007-10-16 07:35:17 +08:00
|
|
|
}
|
|
|
|
|
2009-12-02 16:04:21 +08:00
|
|
|
/// \brief Retrieve the template name that corresponds to a non-empty
|
|
|
|
/// lookup.
|
2010-01-20 08:46:10 +08:00
|
|
|
TemplateName ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin,
|
|
|
|
UnresolvedSetIterator End) {
|
2009-12-02 16:04:21 +08:00
|
|
|
unsigned size = End - Begin;
|
|
|
|
assert(size > 1 && "set is not overloaded!");
|
2009-03-31 06:58:21 +08:00
|
|
|
|
2009-12-02 16:04:21 +08:00
|
|
|
void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
|
|
|
|
size * sizeof(FunctionTemplateDecl*));
|
|
|
|
OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size);
|
|
|
|
|
|
|
|
NamedDecl **Storage = OT->getStorage();
|
2010-01-20 08:46:10 +08:00
|
|
|
for (UnresolvedSetIterator I = Begin; I != End; ++I) {
|
2009-12-02 16:04:21 +08:00
|
|
|
NamedDecl *D = *I;
|
|
|
|
assert(isa<FunctionTemplateDecl>(D) ||
|
|
|
|
(isa<UsingShadowDecl>(D) &&
|
|
|
|
isa<FunctionTemplateDecl>(D->getUnderlyingDecl())));
|
|
|
|
*Storage++ = D;
|
2009-03-31 06:58:21 +08:00
|
|
|
}
|
|
|
|
|
2009-12-02 16:04:21 +08:00
|
|
|
return TemplateName(OT);
|
2009-03-31 06:58:21 +08:00
|
|
|
}
|
|
|
|
|
2009-07-30 02:26:50 +08:00
|
|
|
/// \brief Retrieve the template name that represents a qualified
|
|
|
|
/// template name such as \c std::vector.
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
|
2009-07-30 02:26:50 +08:00
|
|
|
bool TemplateKeyword,
|
2009-12-02 16:04:21 +08:00
|
|
|
TemplateDecl *Template) {
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
// FIXME: Canonicalization?
|
2009-07-30 02:26:50 +08:00
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-30 02:26:50 +08:00
|
|
|
void *InsertPos = 0;
|
|
|
|
QualifiedTemplateName *QTN =
|
2009-12-02 16:04:21 +08:00
|
|
|
QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
|
2009-07-30 02:26:50 +08:00
|
|
|
if (!QTN) {
|
|
|
|
QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template);
|
|
|
|
QualifiedTemplateNames.InsertNode(QTN, InsertPos);
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-30 02:26:50 +08:00
|
|
|
return TemplateName(QTN);
|
|
|
|
}
|
|
|
|
|
2009-03-31 06:58:21 +08:00
|
|
|
/// \brief Retrieve the template name that represents a dependent
|
|
|
|
/// template name such as \c MetaFun::template apply.
|
2009-09-09 23:08:12 +08:00
|
|
|
TemplateName ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
|
2009-03-31 06:58:21 +08:00
|
|
|
const IdentifierInfo *Name) {
|
2009-09-09 23:08:12 +08:00
|
|
|
assert((!NNS || NNS->isDependent()) &&
|
2009-09-09 08:23:06 +08:00
|
|
|
"Nested name specifier must be dependent");
|
2009-03-31 06:58:21 +08:00
|
|
|
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
DependentTemplateName::Profile(ID, NNS, Name);
|
|
|
|
|
|
|
|
void *InsertPos = 0;
|
|
|
|
DependentTemplateName *QTN =
|
|
|
|
DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
|
|
|
|
if (QTN)
|
|
|
|
return TemplateName(QTN);
|
|
|
|
|
|
|
|
NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
|
|
|
|
if (CanonNNS == NNS) {
|
|
|
|
QTN = new (*this,4) DependentTemplateName(NNS, Name);
|
|
|
|
} else {
|
|
|
|
TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
|
|
|
|
QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon);
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
DependentTemplateName *CheckQTN =
|
|
|
|
DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(!CheckQTN && "Dependent type name canonicalization broken");
|
|
|
|
(void)CheckQTN;
|
2009-03-31 06:58:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
DependentTemplateNames.InsertNode(QTN, InsertPos);
|
|
|
|
return TemplateName(QTN);
|
|
|
|
}
|
|
|
|
|
2009-11-04 08:56:37 +08:00
|
|
|
/// \brief Retrieve the template name that represents a dependent
|
|
|
|
/// template name such as \c MetaFun::template operator+.
|
|
|
|
TemplateName
|
|
|
|
ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
|
|
|
|
OverloadedOperatorKind Operator) {
|
|
|
|
assert((!NNS || NNS->isDependent()) &&
|
|
|
|
"Nested name specifier must be dependent");
|
|
|
|
|
|
|
|
llvm::FoldingSetNodeID ID;
|
|
|
|
DependentTemplateName::Profile(ID, NNS, Operator);
|
|
|
|
|
|
|
|
void *InsertPos = 0;
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
DependentTemplateName *QTN
|
|
|
|
= DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
|
2009-11-04 08:56:37 +08:00
|
|
|
|
|
|
|
if (QTN)
|
|
|
|
return TemplateName(QTN);
|
|
|
|
|
|
|
|
NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
|
|
|
|
if (CanonNNS == NNS) {
|
|
|
|
QTN = new (*this,4) DependentTemplateName(NNS, Operator);
|
|
|
|
} else {
|
|
|
|
TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
|
|
|
|
QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon);
|
Fix an obscure crash found in the Boost.MPL test suite, along with a
ton of potential crashes of the same kind. The fundamental problem is
that type creation was following a dangerous pattern when using its
FoldingSets:
1) Use FindNodeOrInsertPos to see if the type is available
2) If not, and we aren't looking at a canonical type, build the
canonical type
3) Build and insert the new node into the FoldingSet
The problem here is that building the canonical type can, in very rare
circumstances, force the hash table inside the FoldingSet to
reallocate. That invalidates the insertion position we computed in
step 1, and in step 3 we end up inserting the new node into the wrong
place. BOOM!
I've audited all of ASTContext, fixing this problem everywhere I found
it. The vast majority of wrong code was C++-specific (and *ahem*
written by me), so I also audited other major folding sets in the C++
code (e.g., template specializations), but found no other instances of
this problem.
llvm-svn: 95315
2010-02-05 02:10:26 +08:00
|
|
|
|
|
|
|
DependentTemplateName *CheckQTN
|
|
|
|
= DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
|
|
|
|
assert(!CheckQTN && "Dependent template name canonicalization broken");
|
|
|
|
(void)CheckQTN;
|
2009-11-04 08:56:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
DependentTemplateNames.InsertNode(QTN, InsertPos);
|
|
|
|
return TemplateName(QTN);
|
|
|
|
}
|
|
|
|
|
2008-11-03 22:12:49 +08:00
|
|
|
/// getFromTargetType - Given one of the integer types provided by
|
2008-11-03 23:57:00 +08:00
|
|
|
/// TargetInfo, produce the corresponding type. The unsigned @p Type
|
|
|
|
/// is actually a value of type @c TargetInfo::IntType.
|
2009-10-24 07:03:21 +08:00
|
|
|
CanQualType ASTContext::getFromTargetType(unsigned Type) const {
|
2008-11-03 22:12:49 +08:00
|
|
|
switch (Type) {
|
2009-10-24 07:03:21 +08:00
|
|
|
case TargetInfo::NoInt: return CanQualType();
|
2008-11-03 22:12:49 +08:00
|
|
|
case TargetInfo::SignedShort: return ShortTy;
|
|
|
|
case TargetInfo::UnsignedShort: return UnsignedShortTy;
|
|
|
|
case TargetInfo::SignedInt: return IntTy;
|
|
|
|
case TargetInfo::UnsignedInt: return UnsignedIntTy;
|
|
|
|
case TargetInfo::SignedLong: return LongTy;
|
|
|
|
case TargetInfo::UnsignedLong: return UnsignedLongTy;
|
|
|
|
case TargetInfo::SignedLongLong: return LongLongTy;
|
|
|
|
case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(false && "Unhandled TargetInfo::IntType value");
|
2009-10-24 07:03:21 +08:00
|
|
|
return CanQualType();
|
2008-11-03 22:12:49 +08:00
|
|
|
}
|
2008-07-25 07:58:27 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Type Predicates.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-01-14 07:34:40 +08:00
|
|
|
/// isObjCNSObjectType - Return true if this is an NSObject object using
|
|
|
|
/// NSObject attribute on a c-style pointer type.
|
|
|
|
/// FIXME - Make it work directly on types.
|
2009-07-16 23:41:00 +08:00
|
|
|
/// FIXME: Move to Type.
|
2009-01-14 07:34:40 +08:00
|
|
|
///
|
|
|
|
bool ASTContext::isObjCNSObjectType(QualType Ty) const {
|
|
|
|
if (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) {
|
|
|
|
if (TypedefDecl *TD = TDT->getDecl())
|
2009-06-30 10:34:44 +08:00
|
|
|
if (TD->getAttr<ObjCNSObjectAttr>())
|
2009-01-14 07:34:40 +08:00
|
|
|
return true;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
return false;
|
2009-01-14 07:34:40 +08:00
|
|
|
}
|
|
|
|
|
2009-02-19 05:49:28 +08:00
|
|
|
/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
|
|
|
|
/// garbage collection attribute.
|
|
|
|
///
|
2009-09-25 03:53:00 +08:00
|
|
|
Qualifiers::GC ASTContext::getObjCGCAttrKind(const QualType &Ty) const {
|
|
|
|
Qualifiers::GC GCAttrs = Qualifiers::GCNone;
|
2009-02-19 05:49:28 +08:00
|
|
|
if (getLangOptions().ObjC1 &&
|
|
|
|
getLangOptions().getGCMode() != LangOptions::NonGC) {
|
2009-02-19 06:53:11 +08:00
|
|
|
GCAttrs = Ty.getObjCGCAttr();
|
2009-02-19 05:49:28 +08:00
|
|
|
// Default behavious under objective-c's gc is for objective-c pointers
|
2009-09-09 23:08:12 +08:00
|
|
|
// (or pointers to them) be treated as though they were declared
|
2009-02-20 07:36:06 +08:00
|
|
|
// as __strong.
|
2009-09-25 03:53:00 +08:00
|
|
|
if (GCAttrs == Qualifiers::GCNone) {
|
2009-09-11 07:38:45 +08:00
|
|
|
if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
|
2009-09-25 03:53:00 +08:00
|
|
|
GCAttrs = Qualifiers::Strong;
|
2009-02-20 07:36:06 +08:00
|
|
|
else if (Ty->isPointerType())
|
2009-07-30 05:53:49 +08:00
|
|
|
return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
|
2009-02-20 07:36:06 +08:00
|
|
|
}
|
2009-04-11 08:00:54 +08:00
|
|
|
// Non-pointers have none gc'able attribute regardless of the attribute
|
|
|
|
// set on them.
|
2009-07-16 23:41:00 +08:00
|
|
|
else if (!Ty->isAnyPointerType() && !Ty->isBlockPointerType())
|
2009-09-25 03:53:00 +08:00
|
|
|
return Qualifiers::GCNone;
|
2009-02-19 05:49:28 +08:00
|
|
|
}
|
2009-02-19 06:53:11 +08:00
|
|
|
return GCAttrs;
|
2009-02-19 05:49:28 +08:00
|
|
|
}
|
|
|
|
|
2008-04-07 14:51:04 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Type Compatibility Testing
|
|
|
|
//===----------------------------------------------------------------------===//
|
2007-11-01 13:03:41 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// areCompatVectorTypes - Return true if the two specified vector types are
|
2008-04-07 14:51:04 +08:00
|
|
|
/// compatible.
|
|
|
|
static bool areCompatVectorTypes(const VectorType *LHS,
|
|
|
|
const VectorType *RHS) {
|
2009-10-23 04:10:53 +08:00
|
|
|
assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
|
2008-04-07 14:51:04 +08:00
|
|
|
return LHS->getElementType() == RHS->getElementType() &&
|
2008-10-06 01:34:18 +08:00
|
|
|
LHS->getNumElements() == RHS->getNumElements();
|
2008-04-07 14:51:04 +08:00
|
|
|
}
|
|
|
|
|
2010-08-06 18:14:59 +08:00
|
|
|
bool ASTContext::areCompatibleVectorTypes(QualType FirstVec,
|
|
|
|
QualType SecondVec) {
|
|
|
|
assert(FirstVec->isVectorType() && "FirstVec should be a vector type");
|
|
|
|
assert(SecondVec->isVectorType() && "SecondVec should be a vector type");
|
|
|
|
|
|
|
|
if (hasSameUnqualifiedType(FirstVec, SecondVec))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// AltiVec vectors types are identical to equivalent GCC vector types
|
|
|
|
const VectorType *First = FirstVec->getAs<VectorType>();
|
|
|
|
const VectorType *Second = SecondVec->getAs<VectorType>();
|
|
|
|
if ((((First->getAltiVecSpecific() == VectorType::AltiVec) &&
|
|
|
|
(Second->getAltiVecSpecific() == VectorType::NotAltiVec)) ||
|
|
|
|
((First->getAltiVecSpecific() == VectorType::NotAltiVec) &&
|
|
|
|
(Second->getAltiVecSpecific() == VectorType::AltiVec))) &&
|
|
|
|
hasSameType(First->getElementType(), Second->getElementType()) &&
|
|
|
|
(First->getNumElements() == Second->getNumElements()))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
|
|
|
|
/// inheritance hierarchy of 'rProto'.
|
2009-08-12 06:02:25 +08:00
|
|
|
bool ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
|
|
|
|
ObjCProtocolDecl *rProto) {
|
2009-07-23 09:01:38 +08:00
|
|
|
if (lProto == rProto)
|
2009-07-11 07:34:53 +08:00
|
|
|
return true;
|
2009-07-23 09:01:38 +08:00
|
|
|
for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(),
|
|
|
|
E = rProto->protocol_end(); PI != E; ++PI)
|
|
|
|
if (ProtocolCompatibleWithProtocol(lProto, *PI))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2009-07-11 07:34:53 +08:00
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...>
|
|
|
|
/// return true if lhs's protocols conform to rhs's protocol; false
|
|
|
|
/// otherwise.
|
|
|
|
bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) {
|
|
|
|
if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType())
|
|
|
|
return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-07-20 06:02:22 +08:00
|
|
|
/// ObjCQualifiedClassTypesAreCompatible - compare Class<p,...> and
|
|
|
|
/// Class<p1, ...>.
|
|
|
|
bool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs,
|
|
|
|
QualType rhs) {
|
|
|
|
const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>();
|
|
|
|
const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
|
|
|
|
assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible");
|
|
|
|
|
|
|
|
for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
|
|
|
|
E = lhsQID->qual_end(); I != E; ++I) {
|
|
|
|
bool match = false;
|
|
|
|
ObjCProtocolDecl *lhsProto = *I;
|
|
|
|
for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
|
|
|
|
E = rhsOPT->qual_end(); J != E; ++J) {
|
|
|
|
ObjCProtocolDecl *rhsProto = *J;
|
|
|
|
if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) {
|
|
|
|
match = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!match)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
|
|
|
|
/// ObjCQualifiedIDType.
|
|
|
|
bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
|
|
|
|
bool compare) {
|
|
|
|
// Allow id<P..> and an 'id' or void* type in all cases.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (lhs->isVoidPointerType() ||
|
2009-07-23 09:01:38 +08:00
|
|
|
lhs->isObjCIdType() || lhs->isObjCClassType())
|
|
|
|
return true;
|
2009-09-09 23:08:12 +08:00
|
|
|
else if (rhs->isVoidPointerType() ||
|
2009-07-23 09:01:38 +08:00
|
|
|
rhs->isObjCIdType() || rhs->isObjCClassType())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
|
2009-09-22 07:43:11 +08:00
|
|
|
const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
if (!rhsOPT) return false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
if (rhsOPT->qual_empty()) {
|
2009-09-09 23:08:12 +08:00
|
|
|
// If the RHS is a unqualified interface pointer "NSString*",
|
2009-07-23 09:01:38 +08:00
|
|
|
// make sure we check the class hierarchy.
|
|
|
|
if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
|
|
|
|
for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
|
|
|
|
E = lhsQID->qual_end(); I != E; ++I) {
|
|
|
|
// when comparing an id<P> on lhs with a static type on rhs,
|
|
|
|
// see if static class implements all of id's protocols, directly or
|
|
|
|
// through its super class and categories.
|
2009-08-12 06:02:25 +08:00
|
|
|
if (!rhsID->ClassImplementsProtocol(*I, true))
|
2009-07-23 09:01:38 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If there are no qualifiers and no interface, we have an 'id'.
|
|
|
|
return true;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
// Both the right and left sides have qualifiers.
|
2009-07-23 09:01:38 +08:00
|
|
|
for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
|
|
|
|
E = lhsQID->qual_end(); I != E; ++I) {
|
|
|
|
ObjCProtocolDecl *lhsProto = *I;
|
|
|
|
bool match = false;
|
2009-07-16 02:40:39 +08:00
|
|
|
|
|
|
|
// when comparing an id<P> on lhs with a static type on rhs,
|
|
|
|
// see if static class implements all of id's protocols, directly or
|
|
|
|
// through its super class and categories.
|
2009-07-23 09:01:38 +08:00
|
|
|
for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
|
|
|
|
E = rhsOPT->qual_end(); J != E; ++J) {
|
|
|
|
ObjCProtocolDecl *rhsProto = *J;
|
|
|
|
if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
|
|
|
|
(compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
|
|
|
|
match = true;
|
2009-07-17 00:21:02 +08:00
|
|
|
break;
|
|
|
|
}
|
2009-07-16 02:40:39 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
// If the RHS is a qualified interface pointer "NSString<P>*",
|
2009-07-23 09:01:38 +08:00
|
|
|
// make sure we check the class hierarchy.
|
|
|
|
if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
|
|
|
|
for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
|
|
|
|
E = lhsQID->qual_end(); I != E; ++I) {
|
|
|
|
// when comparing an id<P> on lhs with a static type on rhs,
|
|
|
|
// see if static class implements all of id's protocols, directly or
|
|
|
|
// through its super class and categories.
|
2009-08-12 06:02:25 +08:00
|
|
|
if (rhsID->ClassImplementsProtocol(*I, true)) {
|
2009-07-23 09:01:38 +08:00
|
|
|
match = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!match)
|
2009-07-16 02:40:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-16 02:40:39 +08:00
|
|
|
return true;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
|
|
|
|
assert(rhsQID && "One of the LHS/RHS should be id<x>");
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
if (const ObjCObjectPointerType *lhsOPT =
|
2009-07-23 09:01:38 +08:00
|
|
|
lhs->getAsObjCInterfacePointerType()) {
|
|
|
|
if (lhsOPT->qual_empty()) {
|
|
|
|
bool match = false;
|
|
|
|
if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
|
|
|
|
for (ObjCObjectPointerType::qual_iterator I = rhsQID->qual_begin(),
|
|
|
|
E = rhsQID->qual_end(); I != E; ++I) {
|
2010-08-10 02:21:43 +08:00
|
|
|
// when comparing an id<P> on rhs with a static type on lhs,
|
|
|
|
// static class must implement all of id's protocols directly or
|
|
|
|
// indirectly through its super class.
|
2010-08-13 04:46:12 +08:00
|
|
|
if (lhsID->ClassImplementsProtocol(*I, true)) {
|
2009-07-23 09:01:38 +08:00
|
|
|
match = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!match)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
// Both the right and left sides have qualifiers.
|
2009-07-23 09:01:38 +08:00
|
|
|
for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(),
|
|
|
|
E = lhsOPT->qual_end(); I != E; ++I) {
|
|
|
|
ObjCProtocolDecl *lhsProto = *I;
|
|
|
|
bool match = false;
|
|
|
|
|
|
|
|
// when comparing an id<P> on lhs with a static type on rhs,
|
|
|
|
// see if static class implements all of id's protocols, directly or
|
|
|
|
// through its super class and categories.
|
|
|
|
for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(),
|
|
|
|
E = rhsQID->qual_end(); J != E; ++J) {
|
|
|
|
ObjCProtocolDecl *rhsProto = *J;
|
|
|
|
if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
|
|
|
|
(compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
|
|
|
|
match = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!match)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// canAssignObjCInterfaces - Return true if the two interface types are
|
|
|
|
/// compatible for assignment from RHS to LHS. This handles validation of any
|
|
|
|
/// protocol qualifiers on the LHS or RHS.
|
|
|
|
///
|
|
|
|
bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
|
|
|
|
const ObjCObjectPointerType *RHSOPT) {
|
2010-05-15 19:32:37 +08:00
|
|
|
const ObjCObjectType* LHS = LHSOPT->getObjectType();
|
|
|
|
const ObjCObjectType* RHS = RHSOPT->getObjectType();
|
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
// If either type represents the built-in 'id' or 'Class' types, return true.
|
2010-05-15 19:32:37 +08:00
|
|
|
if (LHS->isObjCUnqualifiedIdOrClass() ||
|
|
|
|
RHS->isObjCUnqualifiedIdOrClass())
|
2009-07-23 09:01:38 +08:00
|
|
|
return true;
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId())
|
2009-09-09 23:08:12 +08:00
|
|
|
return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
|
|
|
|
QualType(RHSOPT,0),
|
2009-07-23 09:01:38 +08:00
|
|
|
false);
|
2010-07-20 06:02:22 +08:00
|
|
|
|
|
|
|
if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass())
|
|
|
|
return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0),
|
|
|
|
QualType(RHSOPT,0));
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// If we have 2 user-defined types, fall into that path.
|
|
|
|
if (LHS->getInterface() && RHS->getInterface())
|
2009-07-23 09:01:38 +08:00
|
|
|
return canAssignObjCInterfaces(LHS, RHS);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-23 09:01:38 +08:00
|
|
|
return false;
|
2009-07-11 07:34:53 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 08:20:01 +08:00
|
|
|
/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written
|
|
|
|
/// for providing type-safty for objective-c pointers used to pass/return
|
|
|
|
/// arguments in block literals. When passed as arguments, passing 'A*' where
|
|
|
|
/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
|
|
|
|
/// not OK. For the return type, the opposite is not OK.
|
|
|
|
bool ASTContext::canAssignObjCInterfacesInBlockPointer(
|
|
|
|
const ObjCObjectPointerType *LHSOPT,
|
|
|
|
const ObjCObjectPointerType *RHSOPT) {
|
2010-04-07 01:23:39 +08:00
|
|
|
if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
|
2010-03-17 08:20:01 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
if (LHSOPT->isObjCBuiltinType()) {
|
|
|
|
return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType();
|
|
|
|
}
|
|
|
|
|
2010-04-07 01:23:39 +08:00
|
|
|
if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
|
2010-03-17 08:20:01 +08:00
|
|
|
return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
|
|
|
|
QualType(RHSOPT,0),
|
|
|
|
false);
|
|
|
|
|
|
|
|
const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
|
|
|
|
const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
|
|
|
|
if (LHS && RHS) { // We have 2 user-defined types.
|
|
|
|
if (LHS != RHS) {
|
|
|
|
if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
|
|
|
|
return false;
|
|
|
|
if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-10-30 09:13:23 +08:00
|
|
|
/// getIntersectionOfProtocols - This routine finds the intersection of set
|
|
|
|
/// of protocols inherited from two distinct objective-c pointer objects.
|
|
|
|
/// It is used to build composite qualifier list of the composite type of
|
|
|
|
/// the conditional expression involving two objective-c pointer objects.
|
|
|
|
static
|
|
|
|
void getIntersectionOfProtocols(ASTContext &Context,
|
|
|
|
const ObjCObjectPointerType *LHSOPT,
|
|
|
|
const ObjCObjectPointerType *RHSOPT,
|
|
|
|
llvm::SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) {
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
const ObjCObjectType* LHS = LHSOPT->getObjectType();
|
|
|
|
const ObjCObjectType* RHS = RHSOPT->getObjectType();
|
|
|
|
assert(LHS->getInterface() && "LHS must have an interface base");
|
|
|
|
assert(RHS->getInterface() && "RHS must have an interface base");
|
2009-10-30 09:13:23 +08:00
|
|
|
|
|
|
|
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet;
|
|
|
|
unsigned LHSNumProtocols = LHS->getNumProtocols();
|
|
|
|
if (LHSNumProtocols > 0)
|
|
|
|
InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end());
|
|
|
|
else {
|
2010-02-13 03:27:33 +08:00
|
|
|
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
|
2010-05-15 19:32:37 +08:00
|
|
|
Context.CollectInheritedProtocols(LHS->getInterface(),
|
|
|
|
LHSInheritedProtocols);
|
2009-10-30 09:13:23 +08:00
|
|
|
InheritedProtocolSet.insert(LHSInheritedProtocols.begin(),
|
|
|
|
LHSInheritedProtocols.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned RHSNumProtocols = RHS->getNumProtocols();
|
|
|
|
if (RHSNumProtocols > 0) {
|
2010-04-20 00:39:44 +08:00
|
|
|
ObjCProtocolDecl **RHSProtocols =
|
|
|
|
const_cast<ObjCProtocolDecl **>(RHS->qual_begin());
|
2009-10-30 09:13:23 +08:00
|
|
|
for (unsigned i = 0; i < RHSNumProtocols; ++i)
|
|
|
|
if (InheritedProtocolSet.count(RHSProtocols[i]))
|
|
|
|
IntersectionOfProtocols.push_back(RHSProtocols[i]);
|
|
|
|
}
|
|
|
|
else {
|
2010-02-13 03:27:33 +08:00
|
|
|
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols;
|
2010-05-15 19:32:37 +08:00
|
|
|
Context.CollectInheritedProtocols(RHS->getInterface(),
|
|
|
|
RHSInheritedProtocols);
|
2010-02-13 03:27:33 +08:00
|
|
|
for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I =
|
|
|
|
RHSInheritedProtocols.begin(),
|
|
|
|
E = RHSInheritedProtocols.end(); I != E; ++I)
|
|
|
|
if (InheritedProtocolSet.count((*I)))
|
|
|
|
IntersectionOfProtocols.push_back((*I));
|
2009-10-30 09:13:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-28 07:02:38 +08:00
|
|
|
/// areCommonBaseCompatible - Returns common base class of the two classes if
|
|
|
|
/// one found. Note that this is O'2 algorithm. But it will be called as the
|
|
|
|
/// last type comparison in a ?-exp of ObjC pointer types before a
|
|
|
|
/// warning is issued. So, its invokation is extremely rare.
|
|
|
|
QualType ASTContext::areCommonBaseCompatible(
|
2010-05-15 19:32:37 +08:00
|
|
|
const ObjCObjectPointerType *Lptr,
|
|
|
|
const ObjCObjectPointerType *Rptr) {
|
|
|
|
const ObjCObjectType *LHS = Lptr->getObjectType();
|
|
|
|
const ObjCObjectType *RHS = Rptr->getObjectType();
|
|
|
|
const ObjCInterfaceDecl* LDecl = LHS->getInterface();
|
|
|
|
const ObjCInterfaceDecl* RDecl = RHS->getInterface();
|
|
|
|
if (!LDecl || !RDecl)
|
2009-10-28 07:02:38 +08:00
|
|
|
return QualType();
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
while ((LDecl = LDecl->getSuperClass())) {
|
|
|
|
LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl));
|
2009-10-30 09:13:23 +08:00
|
|
|
if (canAssignObjCInterfaces(LHS, RHS)) {
|
2010-05-15 19:32:37 +08:00
|
|
|
llvm::SmallVector<ObjCProtocolDecl *, 8> Protocols;
|
|
|
|
getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols);
|
|
|
|
|
|
|
|
QualType Result = QualType(LHS, 0);
|
|
|
|
if (!Protocols.empty())
|
|
|
|
Result = getObjCObjectType(Result, Protocols.data(), Protocols.size());
|
|
|
|
Result = getObjCObjectPointerType(Result);
|
|
|
|
return Result;
|
2009-10-30 09:13:23 +08:00
|
|
|
}
|
2009-10-28 07:02:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS,
|
|
|
|
const ObjCObjectType *RHS) {
|
|
|
|
assert(LHS->getInterface() && "LHS is not an interface type");
|
|
|
|
assert(RHS->getInterface() && "RHS is not an interface type");
|
|
|
|
|
2008-04-07 14:51:04 +08:00
|
|
|
// Verify that the base decls are compatible: the RHS must be a subclass of
|
|
|
|
// the LHS.
|
2010-05-15 19:32:37 +08:00
|
|
|
if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface()))
|
2008-04-07 14:51:04 +08:00
|
|
|
return false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 14:51:04 +08:00
|
|
|
// RHS must have a superset of the protocols in the LHS. If the LHS is not
|
|
|
|
// protocol qualified at all, then we are good.
|
2009-07-18 23:33:26 +08:00
|
|
|
if (LHS->getNumProtocols() == 0)
|
2008-04-07 14:51:04 +08:00
|
|
|
return true;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-04-07 14:51:04 +08:00
|
|
|
// Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, then it
|
|
|
|
// isn't a superset.
|
2009-07-18 23:33:26 +08:00
|
|
|
if (RHS->getNumProtocols() == 0)
|
2008-04-07 14:51:04 +08:00
|
|
|
return true; // FIXME: should return false!
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(),
|
|
|
|
LHSPE = LHS->qual_end();
|
2009-03-02 00:12:44 +08:00
|
|
|
LHSPI != LHSPE; LHSPI++) {
|
|
|
|
bool RHSImplementsProtocol = false;
|
|
|
|
|
|
|
|
// If the RHS doesn't implement the protocol on the left, the types
|
|
|
|
// are incompatible.
|
2010-05-15 19:32:37 +08:00
|
|
|
for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(),
|
|
|
|
RHSPE = RHS->qual_end();
|
2009-07-17 00:21:02 +08:00
|
|
|
RHSPI != RHSPE; RHSPI++) {
|
|
|
|
if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) {
|
2009-03-02 00:12:44 +08:00
|
|
|
RHSImplementsProtocol = true;
|
2009-07-17 00:21:02 +08:00
|
|
|
break;
|
|
|
|
}
|
2009-03-02 00:12:44 +08:00
|
|
|
}
|
|
|
|
// FIXME: For better diagnostics, consider passing back the protocol name.
|
|
|
|
if (!RHSImplementsProtocol)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// The RHS implements all protocols listed on the LHS.
|
|
|
|
return true;
|
2008-04-07 14:51:04 +08:00
|
|
|
}
|
|
|
|
|
2009-02-13 01:52:19 +08:00
|
|
|
bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
|
|
|
|
// get the "pointed to" types
|
2009-09-22 07:43:11 +08:00
|
|
|
const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
|
|
|
|
const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-11 07:34:53 +08:00
|
|
|
if (!LHSOPT || !RHSOPT)
|
2009-02-13 01:52:19 +08:00
|
|
|
return false;
|
2009-07-11 07:34:53 +08:00
|
|
|
|
|
|
|
return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
|
|
|
|
canAssignObjCInterfaces(RHSOPT, LHSOPT);
|
2009-02-13 01:52:19 +08:00
|
|
|
}
|
|
|
|
|
2010-08-07 19:51:51 +08:00
|
|
|
bool ASTContext::canBindObjCObjectType(QualType To, QualType From) {
|
|
|
|
return canAssignObjCInterfaces(
|
|
|
|
getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
|
|
|
|
getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
|
2007-10-16 04:41:53 +08:00
|
|
|
/// both shall have the identically qualified version of a compatible type.
|
2009-09-09 23:08:12 +08:00
|
|
|
/// C99 6.2.7p1: Two types have compatible types if their types are the
|
2007-10-16 04:41:53 +08:00
|
|
|
/// same. See 6.7.[2,3,5] for additional rules.
|
2010-07-29 23:18:02 +08:00
|
|
|
bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS,
|
|
|
|
bool CompareUnqualified) {
|
2010-02-04 05:02:30 +08:00
|
|
|
if (getLangOptions().CPlusPlus)
|
|
|
|
return hasSameType(LHS, RHS);
|
|
|
|
|
2010-07-29 23:18:02 +08:00
|
|
|
return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull();
|
2008-08-22 08:56:42 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 08:20:01 +08:00
|
|
|
bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) {
|
|
|
|
return !mergeTypes(LHS, RHS, true).isNull();
|
|
|
|
}
|
|
|
|
|
2010-10-25 02:30:18 +08:00
|
|
|
/// mergeTransparentUnionType - if T is a transparent union type and a member
|
|
|
|
/// of T is compatible with SubType, return the merged type, else return
|
|
|
|
/// QualType()
|
|
|
|
QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType,
|
|
|
|
bool OfBlockPointer,
|
|
|
|
bool Unqualified) {
|
|
|
|
if (const RecordType *UT = T->getAsUnionType()) {
|
|
|
|
RecordDecl *UD = UT->getDecl();
|
|
|
|
if (UD->hasAttr<TransparentUnionAttr>()) {
|
|
|
|
for (RecordDecl::field_iterator it = UD->field_begin(),
|
|
|
|
itend = UD->field_end(); it != itend; ++it) {
|
|
|
|
QualType ET = it->getType();
|
|
|
|
QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
|
|
|
|
if (!MT.isNull())
|
|
|
|
return MT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// mergeFunctionArgumentTypes - merge two types which appear as function
|
|
|
|
/// argument types
|
|
|
|
QualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs,
|
|
|
|
bool OfBlockPointer,
|
|
|
|
bool Unqualified) {
|
|
|
|
// GNU extension: two types are compatible if they appear as a function
|
|
|
|
// argument, one of the types is a transparent union type and the other
|
|
|
|
// type is compatible with a union member
|
|
|
|
QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
|
|
|
|
Unqualified);
|
|
|
|
if (!lmerge.isNull())
|
|
|
|
return lmerge;
|
|
|
|
|
|
|
|
QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
|
|
|
|
Unqualified);
|
|
|
|
if (!rmerge.isNull())
|
|
|
|
return rmerge;
|
|
|
|
|
|
|
|
return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified);
|
|
|
|
}
|
|
|
|
|
2010-03-17 08:20:01 +08:00
|
|
|
QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
|
2010-07-29 23:18:02 +08:00
|
|
|
bool OfBlockPointer,
|
|
|
|
bool Unqualified) {
|
2009-09-22 07:43:11 +08:00
|
|
|
const FunctionType *lbase = lhs->getAs<FunctionType>();
|
|
|
|
const FunctionType *rbase = rhs->getAs<FunctionType>();
|
2009-02-27 07:50:07 +08:00
|
|
|
const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
|
|
|
|
const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
|
2008-08-22 08:56:42 +08:00
|
|
|
bool allLTypes = true;
|
|
|
|
bool allRTypes = true;
|
|
|
|
|
|
|
|
// Check return type
|
2010-03-17 08:20:01 +08:00
|
|
|
QualType retType;
|
|
|
|
if (OfBlockPointer)
|
2010-07-29 23:18:02 +08:00
|
|
|
retType = mergeTypes(rbase->getResultType(), lbase->getResultType(), true,
|
|
|
|
Unqualified);
|
2010-03-17 08:20:01 +08:00
|
|
|
else
|
2010-07-29 23:18:02 +08:00
|
|
|
retType = mergeTypes(lbase->getResultType(), rbase->getResultType(),
|
|
|
|
false, Unqualified);
|
2008-08-22 08:56:42 +08:00
|
|
|
if (retType.isNull()) return QualType();
|
2010-07-29 23:18:02 +08:00
|
|
|
|
|
|
|
if (Unqualified)
|
|
|
|
retType = retType.getUnqualifiedType();
|
|
|
|
|
|
|
|
CanQualType LRetType = getCanonicalType(lbase->getResultType());
|
|
|
|
CanQualType RRetType = getCanonicalType(rbase->getResultType());
|
|
|
|
if (Unqualified) {
|
|
|
|
LRetType = LRetType.getUnqualifiedType();
|
|
|
|
RRetType = RRetType.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getCanonicalType(retType) != LRetType)
|
2008-10-06 01:34:18 +08:00
|
|
|
allLTypes = false;
|
2010-07-29 23:18:02 +08:00
|
|
|
if (getCanonicalType(retType) != RRetType)
|
2008-10-06 01:34:18 +08:00
|
|
|
allRTypes = false;
|
2010-04-29 00:20:58 +08:00
|
|
|
// FIXME: double check this
|
|
|
|
// FIXME: should we error if lbase->getRegParmAttr() != 0 &&
|
|
|
|
// rbase->getRegParmAttr() != 0 &&
|
|
|
|
// lbase->getRegParmAttr() != rbase->getRegParmAttr()?
|
2010-03-31 04:24:48 +08:00
|
|
|
FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
|
|
|
|
FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();
|
2010-04-29 00:20:58 +08:00
|
|
|
unsigned RegParm = lbaseInfo.getRegParm() == 0 ? rbaseInfo.getRegParm() :
|
|
|
|
lbaseInfo.getRegParm();
|
|
|
|
bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
|
|
|
|
if (NoReturn != lbaseInfo.getNoReturn() ||
|
|
|
|
RegParm != lbaseInfo.getRegParm())
|
|
|
|
allLTypes = false;
|
|
|
|
if (NoReturn != rbaseInfo.getNoReturn() ||
|
|
|
|
RegParm != rbaseInfo.getRegParm())
|
|
|
|
allRTypes = false;
|
2010-03-31 04:24:48 +08:00
|
|
|
CallingConv lcc = lbaseInfo.getCC();
|
|
|
|
CallingConv rcc = rbaseInfo.getCC();
|
2010-01-19 01:14:39 +08:00
|
|
|
// Compatible functions must have compatible calling conventions
|
2010-02-06 05:31:56 +08:00
|
|
|
if (!isSameCallConv(lcc, rcc))
|
2010-01-19 01:14:39 +08:00
|
|
|
return QualType();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
if (lproto && rproto) { // two C99 style function prototypes
|
2009-05-28 06:11:52 +08:00
|
|
|
assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
|
|
|
|
"C++ shouldn't be here");
|
2008-08-22 08:56:42 +08:00
|
|
|
unsigned lproto_nargs = lproto->getNumArgs();
|
|
|
|
unsigned rproto_nargs = rproto->getNumArgs();
|
|
|
|
|
|
|
|
// Compatible functions must have the same number of arguments
|
|
|
|
if (lproto_nargs != rproto_nargs)
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
// Variadic and non-variadic functions aren't compatible
|
|
|
|
if (lproto->isVariadic() != rproto->isVariadic())
|
|
|
|
return QualType();
|
|
|
|
|
2008-10-27 00:43:14 +08:00
|
|
|
if (lproto->getTypeQuals() != rproto->getTypeQuals())
|
|
|
|
return QualType();
|
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
// Check argument compatibility
|
|
|
|
llvm::SmallVector<QualType, 10> types;
|
|
|
|
for (unsigned i = 0; i < lproto_nargs; i++) {
|
|
|
|
QualType largtype = lproto->getArgType(i).getUnqualifiedType();
|
|
|
|
QualType rargtype = rproto->getArgType(i).getUnqualifiedType();
|
2010-10-25 02:30:18 +08:00
|
|
|
QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype,
|
|
|
|
OfBlockPointer,
|
|
|
|
Unqualified);
|
2008-08-22 08:56:42 +08:00
|
|
|
if (argtype.isNull()) return QualType();
|
2010-07-29 23:18:02 +08:00
|
|
|
|
|
|
|
if (Unqualified)
|
|
|
|
argtype = argtype.getUnqualifiedType();
|
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
types.push_back(argtype);
|
2010-07-29 23:18:02 +08:00
|
|
|
if (Unqualified) {
|
|
|
|
largtype = largtype.getUnqualifiedType();
|
|
|
|
rargtype = rargtype.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
|
2008-10-06 01:34:18 +08:00
|
|
|
if (getCanonicalType(argtype) != getCanonicalType(largtype))
|
|
|
|
allLTypes = false;
|
|
|
|
if (getCanonicalType(argtype) != getCanonicalType(rargtype))
|
|
|
|
allRTypes = false;
|
2008-08-22 08:56:42 +08:00
|
|
|
}
|
|
|
|
if (allLTypes) return lhs;
|
|
|
|
if (allRTypes) return rhs;
|
|
|
|
return getFunctionType(retType, types.begin(), types.size(),
|
2009-07-26 05:26:53 +08:00
|
|
|
lproto->isVariadic(), lproto->getTypeQuals(),
|
2010-03-31 04:24:48 +08:00
|
|
|
false, false, 0, 0,
|
2010-03-31 06:15:11 +08:00
|
|
|
FunctionType::ExtInfo(NoReturn, RegParm, lcc));
|
2008-08-22 08:56:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lproto) allRTypes = false;
|
|
|
|
if (rproto) allLTypes = false;
|
|
|
|
|
2009-02-27 07:50:07 +08:00
|
|
|
const FunctionProtoType *proto = lproto ? lproto : rproto;
|
2008-08-22 08:56:42 +08:00
|
|
|
if (proto) {
|
2009-05-28 06:11:52 +08:00
|
|
|
assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
|
2008-08-22 08:56:42 +08:00
|
|
|
if (proto->isVariadic()) return QualType();
|
|
|
|
// Check that the types are compatible with the types that
|
|
|
|
// would result from default argument promotions (C99 6.7.5.3p15).
|
|
|
|
// The only types actually affected are promotable integer
|
|
|
|
// types and floats, which would be passed as a different
|
|
|
|
// type depending on whether the prototype is visible.
|
|
|
|
unsigned proto_nargs = proto->getNumArgs();
|
|
|
|
for (unsigned i = 0; i < proto_nargs; ++i) {
|
|
|
|
QualType argTy = proto->getArgType(i);
|
2010-02-04 03:27:29 +08:00
|
|
|
|
|
|
|
// Look at the promotion type of enum types, since that is the type used
|
|
|
|
// to pass enum values.
|
|
|
|
if (const EnumType *Enum = argTy->getAs<EnumType>())
|
|
|
|
argTy = Enum->getDecl()->getPromotionType();
|
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
if (argTy->isPromotableIntegerType() ||
|
|
|
|
getCanonicalType(argTy).getUnqualifiedType() == FloatTy)
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (allLTypes) return lhs;
|
|
|
|
if (allRTypes) return rhs;
|
|
|
|
return getFunctionType(retType, proto->arg_type_begin(),
|
2009-07-27 08:44:23 +08:00
|
|
|
proto->getNumArgs(), proto->isVariadic(),
|
2010-03-31 04:24:48 +08:00
|
|
|
proto->getTypeQuals(),
|
|
|
|
false, false, 0, 0,
|
2010-03-31 06:15:11 +08:00
|
|
|
FunctionType::ExtInfo(NoReturn, RegParm, lcc));
|
2008-08-22 08:56:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (allLTypes) return lhs;
|
|
|
|
if (allRTypes) return rhs;
|
2010-03-31 06:15:11 +08:00
|
|
|
FunctionType::ExtInfo Info(NoReturn, RegParm, lcc);
|
2010-03-31 04:24:48 +08:00
|
|
|
return getFunctionNoProtoType(retType, Info);
|
2008-08-22 08:56:42 +08:00
|
|
|
}
|
|
|
|
|
2010-03-17 08:20:01 +08:00
|
|
|
QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
|
2010-07-29 23:18:02 +08:00
|
|
|
bool OfBlockPointer,
|
|
|
|
bool Unqualified) {
|
2007-12-03 15:33:35 +08:00
|
|
|
// C++ [expr]: If an expression initially has the type "reference to T", the
|
|
|
|
// type is adjusted to "T" prior to any further analysis, the expression
|
|
|
|
// designates the object or function denoted by the reference, and the
|
2009-03-17 07:22:08 +08:00
|
|
|
// expression is an lvalue unless the reference is an rvalue reference and
|
|
|
|
// the expression is a function call (possibly inside parentheses).
|
2010-02-04 05:02:30 +08:00
|
|
|
assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?");
|
|
|
|
assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?");
|
2010-07-29 23:18:02 +08:00
|
|
|
|
|
|
|
if (Unqualified) {
|
|
|
|
LHS = LHS.getUnqualifiedType();
|
|
|
|
RHS = RHS.getUnqualifiedType();
|
|
|
|
}
|
2010-02-04 05:02:30 +08:00
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
QualType LHSCan = getCanonicalType(LHS),
|
|
|
|
RHSCan = getCanonicalType(RHS);
|
|
|
|
|
2008-04-07 13:37:56 +08:00
|
|
|
// If two types are identical, they are compatible.
|
2008-08-22 08:56:42 +08:00
|
|
|
if (LHSCan == RHSCan)
|
|
|
|
return LHS;
|
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// If the qualifiers are different, the types aren't compatible... mostly.
|
First part of changes to eliminate problems with cv-qualifiers and
sugared types. The basic problem is that our qualifier accessors
(getQualifiers, getCVRQualifiers, isConstQualified, etc.) only look at
the current QualType and not at any qualifiers that come from sugared
types, meaning that we won't see these qualifiers through, e.g.,
typedefs:
typedef const int CInt;
typedef CInt Self;
Self.isConstQualified() currently returns false!
Various bugs (e.g., PR5383) have cropped up all over the front end due
to such problems. I'm addressing this problem by splitting each
qualifier accessor into two versions:
- the "local" version only returns qualifiers on this particular
QualType instance
- the "normal" version that will eventually combine qualifiers from this
QualType instance with the qualifiers on the canonical type to
produce the full set of qualifiers.
This commit adds the local versions and switches a few callers from
the "normal" version (e.g., isConstQualified) over to the "local"
version (e.g., isLocalConstQualified) when that is the right thing to
do, e.g., because we're printing or serializing the qualifiers. Also,
switch a bunch of
Context.getCanonicalType(T1).getUnqualifiedType() == Context.getCanonicalType(T2).getQualifiedType()
expressions over to
Context.hasSameUnqualifiedType(T1, T2)
llvm-svn: 88969
2009-11-17 05:35:15 +08:00
|
|
|
Qualifiers LQuals = LHSCan.getLocalQualifiers();
|
|
|
|
Qualifiers RQuals = RHSCan.getLocalQualifiers();
|
2009-09-25 03:53:00 +08:00
|
|
|
if (LQuals != RQuals) {
|
|
|
|
// If any of these qualifiers are different, we have a type
|
|
|
|
// mismatch.
|
|
|
|
if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
|
|
|
|
LQuals.getAddressSpace() != RQuals.getAddressSpace())
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
// Exactly one GC qualifier difference is allowed: __strong is
|
|
|
|
// okay if the other type has no GC qualifier but is an Objective
|
|
|
|
// C object pointer (i.e. implicitly strong by default). We fix
|
|
|
|
// this by pretending that the unqualified type was actually
|
|
|
|
// qualified __strong.
|
|
|
|
Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
|
|
|
|
Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
|
|
|
|
assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
|
|
|
|
|
|
|
|
if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
|
|
|
|
return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
|
|
|
|
}
|
|
|
|
if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
|
|
|
|
return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
|
|
|
|
}
|
2008-08-22 08:56:42 +08:00
|
|
|
return QualType();
|
2009-09-25 03:53:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, qualifiers are equal.
|
2008-08-22 08:56:42 +08:00
|
|
|
|
2009-06-01 09:22:52 +08:00
|
|
|
Type::TypeClass LHSClass = LHSCan->getTypeClass();
|
|
|
|
Type::TypeClass RHSClass = RHSCan->getTypeClass();
|
2008-04-07 13:37:56 +08:00
|
|
|
|
2008-01-14 13:45:46 +08:00
|
|
|
// We want to consider the two function types to be the same for these
|
|
|
|
// comparisons, just force one to the other.
|
|
|
|
if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
|
|
|
|
if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
|
2008-02-12 16:23:06 +08:00
|
|
|
|
|
|
|
// Same as above for arrays
|
2008-04-07 13:43:21 +08:00
|
|
|
if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
|
|
|
|
LHSClass = Type::ConstantArray;
|
|
|
|
if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
|
|
|
|
RHSClass = Type::ConstantArray;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
// ObjCInterfaces are just specialized ObjCObjects.
|
|
|
|
if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
|
|
|
|
if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
|
|
|
|
|
2008-04-19 07:10:10 +08:00
|
|
|
// Canonicalize ExtVector -> Vector.
|
|
|
|
if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
|
|
|
|
if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-12-11 04:07:25 +08:00
|
|
|
// If the canonical type classes don't match.
|
|
|
|
if (LHSClass != RHSClass) {
|
2008-01-14 13:45:46 +08:00
|
|
|
// C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
|
2009-09-09 23:08:12 +08:00
|
|
|
// a signed integer type, or an unsigned integer type.
|
2009-12-09 17:09:27 +08:00
|
|
|
// Compatibility is based on the underlying type, not the promotion
|
|
|
|
// type.
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const EnumType* ETy = LHS->getAs<EnumType>()) {
|
2008-08-22 08:56:42 +08:00
|
|
|
if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType())
|
|
|
|
return RHS;
|
2008-02-12 16:46:17 +08:00
|
|
|
}
|
2009-09-22 07:43:11 +08:00
|
|
|
if (const EnumType* ETy = RHS->getAs<EnumType>()) {
|
2008-08-22 08:56:42 +08:00
|
|
|
if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType())
|
|
|
|
return LHS;
|
2008-02-12 16:46:17 +08:00
|
|
|
}
|
2008-01-14 13:45:46 +08:00
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
return QualType();
|
2007-10-16 04:41:53 +08:00
|
|
|
}
|
2008-08-22 08:56:42 +08:00
|
|
|
|
2008-01-10 06:43:08 +08:00
|
|
|
// The canonical type classes match.
|
2008-01-14 13:45:46 +08:00
|
|
|
switch (LHSClass) {
|
2009-02-27 07:50:07 +08:00
|
|
|
#define TYPE(Class, Base)
|
|
|
|
#define ABSTRACT_TYPE(Class, Base)
|
2010-03-02 07:49:17 +08:00
|
|
|
#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
|
2009-02-27 07:50:07 +08:00
|
|
|
#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
|
|
|
|
#define DEPENDENT_TYPE(Class, Base) case Type::Class:
|
|
|
|
#include "clang/AST/TypeNodes.def"
|
|
|
|
assert(false && "Non-canonical and dependent types shouldn't get here");
|
|
|
|
return QualType();
|
|
|
|
|
2009-03-17 07:22:08 +08:00
|
|
|
case Type::LValueReference:
|
|
|
|
case Type::RValueReference:
|
2009-02-27 07:50:07 +08:00
|
|
|
case Type::MemberPointer:
|
|
|
|
assert(false && "C++ should never be in mergeTypes");
|
|
|
|
return QualType();
|
|
|
|
|
2010-05-15 19:32:37 +08:00
|
|
|
case Type::ObjCInterface:
|
2009-02-27 07:50:07 +08:00
|
|
|
case Type::IncompleteArray:
|
|
|
|
case Type::VariableArray:
|
|
|
|
case Type::FunctionProto:
|
|
|
|
case Type::ExtVector:
|
|
|
|
assert(false && "Types are eliminated above");
|
|
|
|
return QualType();
|
|
|
|
|
2008-01-14 13:45:46 +08:00
|
|
|
case Type::Pointer:
|
2008-08-22 08:56:42 +08:00
|
|
|
{
|
|
|
|
// Merge two pointer types, while trying to preserve typedef info
|
2009-07-30 05:53:49 +08:00
|
|
|
QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
|
|
|
|
QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
|
2010-07-29 23:18:02 +08:00
|
|
|
if (Unqualified) {
|
|
|
|
LHSPointee = LHSPointee.getUnqualifiedType();
|
|
|
|
RHSPointee = RHSPointee.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
|
|
|
|
Unqualified);
|
2008-08-22 08:56:42 +08:00
|
|
|
if (ResultType.isNull()) return QualType();
|
2009-06-02 13:28:56 +08:00
|
|
|
if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
|
2008-10-06 01:34:18 +08:00
|
|
|
return LHS;
|
2009-06-02 13:28:56 +08:00
|
|
|
if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
|
2008-10-06 01:34:18 +08:00
|
|
|
return RHS;
|
2008-08-22 08:56:42 +08:00
|
|
|
return getPointerType(ResultType);
|
|
|
|
}
|
2008-12-11 01:49:55 +08:00
|
|
|
case Type::BlockPointer:
|
|
|
|
{
|
|
|
|
// Merge two block pointer types, while trying to preserve typedef info
|
2009-07-30 05:53:49 +08:00
|
|
|
QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
|
|
|
|
QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
|
2010-07-29 23:18:02 +08:00
|
|
|
if (Unqualified) {
|
|
|
|
LHSPointee = LHSPointee.getUnqualifiedType();
|
|
|
|
RHSPointee = RHSPointee.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
|
|
|
|
Unqualified);
|
2008-12-11 01:49:55 +08:00
|
|
|
if (ResultType.isNull()) return QualType();
|
|
|
|
if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
|
|
|
|
return LHS;
|
|
|
|
if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
|
|
|
|
return RHS;
|
|
|
|
return getBlockPointerType(ResultType);
|
|
|
|
}
|
2008-01-14 13:45:46 +08:00
|
|
|
case Type::ConstantArray:
|
2008-08-22 08:56:42 +08:00
|
|
|
{
|
|
|
|
const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
|
|
|
|
const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
|
|
|
|
if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
QualType LHSElem = getAsArrayType(LHS)->getElementType();
|
|
|
|
QualType RHSElem = getAsArrayType(RHS)->getElementType();
|
2010-07-29 23:18:02 +08:00
|
|
|
if (Unqualified) {
|
|
|
|
LHSElem = LHSElem.getUnqualifiedType();
|
|
|
|
RHSElem = RHSElem.getUnqualifiedType();
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified);
|
2008-08-22 08:56:42 +08:00
|
|
|
if (ResultType.isNull()) return QualType();
|
2008-10-06 01:34:18 +08:00
|
|
|
if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
|
|
|
|
return LHS;
|
|
|
|
if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
|
|
|
|
return RHS;
|
2008-08-22 09:48:21 +08:00
|
|
|
if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
|
|
|
|
ArrayType::ArraySizeModifier(), 0);
|
|
|
|
if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
|
|
|
|
ArrayType::ArraySizeModifier(), 0);
|
2008-08-22 08:56:42 +08:00
|
|
|
const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
|
|
|
|
const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
|
2008-10-06 01:34:18 +08:00
|
|
|
if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
|
|
|
|
return LHS;
|
|
|
|
if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
|
|
|
|
return RHS;
|
2008-08-22 08:56:42 +08:00
|
|
|
if (LVAT) {
|
|
|
|
// FIXME: This isn't correct! But tricky to implement because
|
|
|
|
// the array's size has to be the size of LHS, but the type
|
|
|
|
// has to be different.
|
|
|
|
return LHS;
|
|
|
|
}
|
|
|
|
if (RVAT) {
|
|
|
|
// FIXME: This isn't correct! But tricky to implement because
|
|
|
|
// the array's size has to be the size of RHS, but the type
|
|
|
|
// has to be different.
|
|
|
|
return RHS;
|
|
|
|
}
|
2008-08-22 09:48:21 +08:00
|
|
|
if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
|
|
|
|
if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
|
2009-07-06 23:59:29 +08:00
|
|
|
return getIncompleteArrayType(ResultType,
|
|
|
|
ArrayType::ArraySizeModifier(), 0);
|
2008-08-22 08:56:42 +08:00
|
|
|
}
|
2008-01-14 13:45:46 +08:00
|
|
|
case Type::FunctionNoProto:
|
2010-07-29 23:18:02 +08:00
|
|
|
return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
|
2009-02-27 07:50:07 +08:00
|
|
|
case Type::Record:
|
|
|
|
case Type::Enum:
|
2008-08-22 08:56:42 +08:00
|
|
|
return QualType();
|
2008-01-14 13:45:46 +08:00
|
|
|
case Type::Builtin:
|
2008-04-07 13:55:38 +08:00
|
|
|
// Only exactly equal builtin types are compatible, which is tested above.
|
2008-08-22 08:56:42 +08:00
|
|
|
return QualType();
|
2009-01-29 05:22:12 +08:00
|
|
|
case Type::Complex:
|
|
|
|
// Distinct complex types are incompatible.
|
|
|
|
return QualType();
|
2008-04-07 13:55:38 +08:00
|
|
|
case Type::Vector:
|
2009-02-28 07:04:43 +08:00
|
|
|
// FIXME: The merged type should be an ExtVector!
|
2010-03-13 07:14:13 +08:00
|
|
|
if (areCompatVectorTypes(LHSCan->getAs<VectorType>(),
|
|
|
|
RHSCan->getAs<VectorType>()))
|
2008-08-22 08:56:42 +08:00
|
|
|
return LHS;
|
2008-10-06 01:34:18 +08:00
|
|
|
return QualType();
|
2010-05-15 19:32:37 +08:00
|
|
|
case Type::ObjCObject: {
|
|
|
|
// Check if the types are assignment compatible.
|
2009-02-28 07:04:43 +08:00
|
|
|
// FIXME: This should be type compatibility, e.g. whether
|
|
|
|
// "LHS x; RHS x;" at global scope is legal.
|
2010-05-15 19:32:37 +08:00
|
|
|
const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>();
|
|
|
|
const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>();
|
|
|
|
if (canAssignObjCInterfaces(LHSIface, RHSIface))
|
2009-02-22 00:18:07 +08:00
|
|
|
return LHS;
|
|
|
|
|
2008-08-22 08:56:42 +08:00
|
|
|
return QualType();
|
2009-02-22 01:14:49 +08:00
|
|
|
}
|
2009-07-11 07:34:53 +08:00
|
|
|
case Type::ObjCObjectPointer: {
|
2010-03-17 08:20:01 +08:00
|
|
|
if (OfBlockPointer) {
|
|
|
|
if (canAssignObjCInterfacesInBlockPointer(
|
|
|
|
LHS->getAs<ObjCObjectPointerType>(),
|
|
|
|
RHS->getAs<ObjCObjectPointerType>()))
|
|
|
|
return LHS;
|
|
|
|
return QualType();
|
|
|
|
}
|
2009-09-22 07:43:11 +08:00
|
|
|
if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(),
|
|
|
|
RHS->getAs<ObjCObjectPointerType>()))
|
2009-07-11 07:34:53 +08:00
|
|
|
return LHS;
|
|
|
|
|
2008-12-11 06:14:21 +08:00
|
|
|
return QualType();
|
2010-03-17 08:20:01 +08:00
|
|
|
}
|
2007-10-16 04:41:53 +08:00
|
|
|
}
|
2009-02-27 07:50:07 +08:00
|
|
|
|
|
|
|
return QualType();
|
2007-10-16 04:41:53 +08:00
|
|
|
}
|
2007-11-01 01:10:13 +08:00
|
|
|
|
2010-05-20 05:37:30 +08:00
|
|
|
/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and
|
|
|
|
/// 'RHS' attributes and returns the merged version; including for function
|
|
|
|
/// return types.
|
|
|
|
QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) {
|
|
|
|
QualType LHSCan = getCanonicalType(LHS),
|
|
|
|
RHSCan = getCanonicalType(RHS);
|
|
|
|
// If two types are identical, they are compatible.
|
|
|
|
if (LHSCan == RHSCan)
|
|
|
|
return LHS;
|
|
|
|
if (RHSCan->isFunctionType()) {
|
|
|
|
if (!LHSCan->isFunctionType())
|
|
|
|
return QualType();
|
|
|
|
QualType OldReturnType =
|
|
|
|
cast<FunctionType>(RHSCan.getTypePtr())->getResultType();
|
|
|
|
QualType NewReturnType =
|
|
|
|
cast<FunctionType>(LHSCan.getTypePtr())->getResultType();
|
|
|
|
QualType ResReturnType =
|
|
|
|
mergeObjCGCQualifiers(NewReturnType, OldReturnType);
|
|
|
|
if (ResReturnType.isNull())
|
|
|
|
return QualType();
|
|
|
|
if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
|
|
|
|
// id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
|
|
|
|
// In either case, use OldReturnType to build the new function type.
|
|
|
|
const FunctionType *F = LHS->getAs<FunctionType>();
|
|
|
|
if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) {
|
|
|
|
FunctionType::ExtInfo Info = getFunctionExtInfo(LHS);
|
|
|
|
QualType ResultType
|
|
|
|
= getFunctionType(OldReturnType, FPT->arg_type_begin(),
|
|
|
|
FPT->getNumArgs(), FPT->isVariadic(),
|
|
|
|
FPT->getTypeQuals(),
|
|
|
|
FPT->hasExceptionSpec(),
|
|
|
|
FPT->hasAnyExceptionSpec(),
|
|
|
|
FPT->getNumExceptions(),
|
|
|
|
FPT->exception_begin(),
|
|
|
|
Info);
|
|
|
|
return ResultType;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the qualifiers are different, the types can still be merged.
|
|
|
|
Qualifiers LQuals = LHSCan.getLocalQualifiers();
|
|
|
|
Qualifiers RQuals = RHSCan.getLocalQualifiers();
|
|
|
|
if (LQuals != RQuals) {
|
|
|
|
// If any of these qualifiers are different, we have a type mismatch.
|
|
|
|
if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
|
|
|
|
LQuals.getAddressSpace() != RQuals.getAddressSpace())
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
// Exactly one GC qualifier difference is allowed: __strong is
|
|
|
|
// okay if the other type has no GC qualifier but is an Objective
|
|
|
|
// C object pointer (i.e. implicitly strong by default). We fix
|
|
|
|
// this by pretending that the unqualified type was actually
|
|
|
|
// qualified __strong.
|
|
|
|
Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
|
|
|
|
Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
|
|
|
|
assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
|
|
|
|
|
|
|
|
if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
if (GC_L == Qualifiers::Strong)
|
|
|
|
return LHS;
|
|
|
|
if (GC_R == Qualifiers::Strong)
|
|
|
|
return RHS;
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) {
|
|
|
|
QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType();
|
|
|
|
QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType();
|
|
|
|
QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT);
|
|
|
|
if (ResQT == LHSBaseQT)
|
|
|
|
return LHS;
|
|
|
|
if (ResQT == RHSBaseQT)
|
|
|
|
return RHS;
|
|
|
|
}
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
2008-06-28 14:23:08 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Integer Predicates
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-01-16 15:15:35 +08:00
|
|
|
|
2008-06-28 14:23:08 +08:00
|
|
|
unsigned ASTContext::getIntWidth(QualType T) {
|
2009-12-09 17:09:27 +08:00
|
|
|
if (EnumType *ET = dyn_cast<EnumType>(T))
|
2009-12-11 06:29:29 +08:00
|
|
|
T = ET->getDecl()->getIntegerType();
|
2010-10-09 07:50:27 +08:00
|
|
|
if (T->isBooleanType())
|
|
|
|
return 1;
|
2009-02-13 10:31:07 +08:00
|
|
|
// For builtin types, just use the standard type sizing method
|
2008-06-28 14:23:08 +08:00
|
|
|
return (unsigned)getTypeSize(T);
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ASTContext::getCorrespondingUnsignedType(QualType T) {
|
2010-07-23 23:58:24 +08:00
|
|
|
assert(T->hasSignedIntegerRepresentation() && "Unexpected type");
|
2009-10-18 04:33:28 +08:00
|
|
|
|
|
|
|
// Turn <4 x signed int> -> <4 x unsigned int>
|
|
|
|
if (const VectorType *VTy = T->getAs<VectorType>())
|
|
|
|
return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
|
2010-06-23 14:00:24 +08:00
|
|
|
VTy->getNumElements(), VTy->getAltiVecSpecific());
|
2009-10-18 04:33:28 +08:00
|
|
|
|
|
|
|
// For enums, we return the unsigned version of the base type.
|
|
|
|
if (const EnumType *ETy = T->getAs<EnumType>())
|
2008-06-28 14:23:08 +08:00
|
|
|
T = ETy->getDecl()->getIntegerType();
|
2009-10-18 04:33:28 +08:00
|
|
|
|
|
|
|
const BuiltinType *BTy = T->getAs<BuiltinType>();
|
|
|
|
assert(BTy && "Unexpected signed integer type");
|
2008-06-28 14:23:08 +08:00
|
|
|
switch (BTy->getKind()) {
|
|
|
|
case BuiltinType::Char_S:
|
|
|
|
case BuiltinType::SChar:
|
|
|
|
return UnsignedCharTy;
|
|
|
|
case BuiltinType::Short:
|
|
|
|
return UnsignedShortTy;
|
|
|
|
case BuiltinType::Int:
|
|
|
|
return UnsignedIntTy;
|
|
|
|
case BuiltinType::Long:
|
|
|
|
return UnsignedLongTy;
|
|
|
|
case BuiltinType::LongLong:
|
|
|
|
return UnsignedLongLongTy;
|
2009-04-30 10:43:43 +08:00
|
|
|
case BuiltinType::Int128:
|
|
|
|
return UnsignedInt128Ty;
|
2008-06-28 14:23:08 +08:00
|
|
|
default:
|
|
|
|
assert(0 && "Unexpected signed integer type");
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-10 06:27:44 +08:00
|
|
|
ExternalASTSource::~ExternalASTSource() { }
|
|
|
|
|
|
|
|
void ExternalASTSource::PrintStats() { }
|
2009-06-14 08:45:47 +08:00
|
|
|
|
2010-10-25 01:26:36 +08:00
|
|
|
ASTMutationListener::~ASTMutationListener() { }
|
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Builtin Type Computation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
|
2010-10-02 06:42:38 +08:00
|
|
|
/// pointer over the consumed characters. This returns the resultant type. If
|
|
|
|
/// AllowTypeModifiers is false then modifier like * are not parsed, just basic
|
|
|
|
/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of
|
|
|
|
/// a vector of "i*".
|
2010-10-02 06:53:11 +08:00
|
|
|
///
|
|
|
|
/// RequiresICE is filled in on return to indicate whether the value is required
|
|
|
|
/// to be an Integer Constant Expression.
|
2009-09-09 23:08:12 +08:00
|
|
|
static QualType DecodeTypeFromStr(const char *&Str, ASTContext &Context,
|
2009-06-14 08:45:47 +08:00
|
|
|
ASTContext::GetBuiltinTypeError &Error,
|
2010-10-02 06:53:11 +08:00
|
|
|
bool &RequiresICE,
|
2010-10-02 06:42:38 +08:00
|
|
|
bool AllowTypeModifiers) {
|
2009-06-14 08:45:47 +08:00
|
|
|
// Modifiers.
|
|
|
|
int HowLong = 0;
|
|
|
|
bool Signed = false, Unsigned = false;
|
2010-10-02 06:53:11 +08:00
|
|
|
RequiresICE = false;
|
2010-10-01 15:13:18 +08:00
|
|
|
|
2010-10-02 06:42:38 +08:00
|
|
|
// Read the prefixed modifiers first.
|
2009-06-14 08:45:47 +08:00
|
|
|
bool Done = false;
|
|
|
|
while (!Done) {
|
|
|
|
switch (*Str++) {
|
2009-09-09 23:08:12 +08:00
|
|
|
default: Done = true; --Str; break;
|
2010-10-01 15:13:18 +08:00
|
|
|
case 'I':
|
2010-10-02 06:53:11 +08:00
|
|
|
RequiresICE = true;
|
2010-10-01 15:13:18 +08:00
|
|
|
break;
|
2009-06-14 08:45:47 +08:00
|
|
|
case 'S':
|
|
|
|
assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
|
|
|
|
assert(!Signed && "Can't use 'S' modifier multiple times!");
|
|
|
|
Signed = true;
|
|
|
|
break;
|
|
|
|
case 'U':
|
|
|
|
assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
|
|
|
|
assert(!Unsigned && "Can't use 'S' modifier multiple times!");
|
|
|
|
Unsigned = true;
|
|
|
|
break;
|
|
|
|
case 'L':
|
|
|
|
assert(HowLong <= 2 && "Can't have LLLL modifier");
|
|
|
|
++HowLong;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType Type;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
// Read the base type.
|
|
|
|
switch (*Str++) {
|
|
|
|
default: assert(0 && "Unknown builtin type letter!");
|
|
|
|
case 'v':
|
|
|
|
assert(HowLong == 0 && !Signed && !Unsigned &&
|
|
|
|
"Bad modifiers used with 'v'!");
|
|
|
|
Type = Context.VoidTy;
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
assert(HowLong == 0 && !Signed && !Unsigned &&
|
|
|
|
"Bad modifiers used with 'f'!");
|
|
|
|
Type = Context.FloatTy;
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
assert(HowLong < 2 && !Signed && !Unsigned &&
|
|
|
|
"Bad modifiers used with 'd'!");
|
|
|
|
if (HowLong)
|
|
|
|
Type = Context.LongDoubleTy;
|
|
|
|
else
|
|
|
|
Type = Context.DoubleTy;
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
assert(HowLong == 0 && "Bad modifiers used with 's'!");
|
|
|
|
if (Unsigned)
|
|
|
|
Type = Context.UnsignedShortTy;
|
|
|
|
else
|
|
|
|
Type = Context.ShortTy;
|
|
|
|
break;
|
|
|
|
case 'i':
|
|
|
|
if (HowLong == 3)
|
|
|
|
Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
|
|
|
|
else if (HowLong == 2)
|
|
|
|
Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
|
|
|
|
else if (HowLong == 1)
|
|
|
|
Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
|
|
|
|
else
|
|
|
|
Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
|
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
assert(HowLong == 0 && "Bad modifiers used with 'c'!");
|
|
|
|
if (Signed)
|
|
|
|
Type = Context.SignedCharTy;
|
|
|
|
else if (Unsigned)
|
|
|
|
Type = Context.UnsignedCharTy;
|
|
|
|
else
|
|
|
|
Type = Context.CharTy;
|
|
|
|
break;
|
|
|
|
case 'b': // boolean
|
|
|
|
assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
|
|
|
|
Type = Context.BoolTy;
|
|
|
|
break;
|
|
|
|
case 'z': // size_t.
|
|
|
|
assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
|
|
|
|
Type = Context.getSizeType();
|
|
|
|
break;
|
|
|
|
case 'F':
|
|
|
|
Type = Context.getCFConstantStringType();
|
|
|
|
break;
|
|
|
|
case 'a':
|
|
|
|
Type = Context.getBuiltinVaListType();
|
|
|
|
assert(!Type.isNull() && "builtin va list type not initialized!");
|
|
|
|
break;
|
|
|
|
case 'A':
|
|
|
|
// This is a "reference" to a va_list; however, what exactly
|
|
|
|
// this means depends on how va_list is defined. There are two
|
|
|
|
// different kinds of va_list: ones passed by value, and ones
|
|
|
|
// passed by reference. An example of a by-value va_list is
|
|
|
|
// x86, where va_list is a char*. An example of by-ref va_list
|
|
|
|
// is x86-64, where va_list is a __va_list_tag[1]. For x86,
|
|
|
|
// we want this argument to be a char*&; for x86-64, we want
|
|
|
|
// it to be a __va_list_tag*.
|
|
|
|
Type = Context.getBuiltinVaListType();
|
|
|
|
assert(!Type.isNull() && "builtin va list type not initialized!");
|
2010-10-02 06:53:11 +08:00
|
|
|
if (Type->isArrayType())
|
2009-06-14 08:45:47 +08:00
|
|
|
Type = Context.getArrayDecayedType(Type);
|
2010-10-02 06:53:11 +08:00
|
|
|
else
|
2009-06-14 08:45:47 +08:00
|
|
|
Type = Context.getLValueReferenceType(Type);
|
|
|
|
break;
|
|
|
|
case 'V': {
|
|
|
|
char *End;
|
|
|
|
unsigned NumElements = strtoul(Str, &End, 10);
|
|
|
|
assert(End != Str && "Missing vector size");
|
|
|
|
Str = End;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-10-02 06:53:11 +08:00
|
|
|
QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
|
|
|
|
RequiresICE, false);
|
|
|
|
assert(!RequiresICE && "Can't require vector ICE");
|
2010-10-02 06:42:38 +08:00
|
|
|
|
|
|
|
// TODO: No way to make AltiVec vectors in builtins yet.
|
2010-06-23 14:00:24 +08:00
|
|
|
Type = Context.getVectorType(ElementType, NumElements,
|
|
|
|
VectorType::NotAltiVec);
|
2009-06-14 08:45:47 +08:00
|
|
|
break;
|
|
|
|
}
|
2009-09-29 05:45:01 +08:00
|
|
|
case 'X': {
|
2010-10-02 06:53:11 +08:00
|
|
|
QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
|
|
|
|
false);
|
|
|
|
assert(!RequiresICE && "Can't require complex ICE");
|
2009-09-29 05:45:01 +08:00
|
|
|
Type = Context.getComplexType(ElementType);
|
|
|
|
break;
|
|
|
|
}
|
2009-07-29 06:49:34 +08:00
|
|
|
case 'P':
|
2009-07-08 00:35:42 +08:00
|
|
|
Type = Context.getFILEType();
|
|
|
|
if (Type.isNull()) {
|
2009-07-29 07:57:15 +08:00
|
|
|
Error = ASTContext::GE_Missing_stdio;
|
2009-06-14 08:45:47 +08:00
|
|
|
return QualType();
|
|
|
|
}
|
2009-07-29 07:47:15 +08:00
|
|
|
break;
|
2009-07-29 06:49:34 +08:00
|
|
|
case 'J':
|
2009-07-29 07:57:15 +08:00
|
|
|
if (Signed)
|
2009-07-28 10:25:19 +08:00
|
|
|
Type = Context.getsigjmp_bufType();
|
2009-07-29 07:57:15 +08:00
|
|
|
else
|
|
|
|
Type = Context.getjmp_bufType();
|
|
|
|
|
2009-07-29 07:47:15 +08:00
|
|
|
if (Type.isNull()) {
|
2009-07-29 07:57:15 +08:00
|
|
|
Error = ASTContext::GE_Missing_setjmp;
|
2009-07-29 07:47:15 +08:00
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
break;
|
2009-07-28 10:25:19 +08:00
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-10-02 06:42:38 +08:00
|
|
|
// If there are modifiers and if we're allowed to parse them, go for it.
|
|
|
|
Done = !AllowTypeModifiers;
|
2009-06-14 08:45:47 +08:00
|
|
|
while (!Done) {
|
2010-03-12 12:21:28 +08:00
|
|
|
switch (char c = *Str++) {
|
2010-10-02 06:42:38 +08:00
|
|
|
default: Done = true; --Str; break;
|
|
|
|
case '*':
|
|
|
|
case '&': {
|
|
|
|
// Both pointers and references can have their pointee types
|
|
|
|
// qualified with an address space.
|
|
|
|
char *End;
|
|
|
|
unsigned AddrSpace = strtoul(Str, &End, 10);
|
|
|
|
if (End != Str && AddrSpace != 0) {
|
|
|
|
Type = Context.getAddrSpaceQualType(Type, AddrSpace);
|
|
|
|
Str = End;
|
|
|
|
}
|
|
|
|
if (c == '*')
|
|
|
|
Type = Context.getPointerType(Type);
|
|
|
|
else
|
|
|
|
Type = Context.getLValueReferenceType(Type);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// FIXME: There's no way to have a built-in with an rvalue ref arg.
|
|
|
|
case 'C':
|
|
|
|
Type = Type.withConst();
|
|
|
|
break;
|
|
|
|
case 'D':
|
|
|
|
Type = Context.getVolatileType(Type);
|
|
|
|
break;
|
2009-06-14 08:45:47 +08:00
|
|
|
}
|
|
|
|
}
|
2010-10-01 15:13:18 +08:00
|
|
|
|
2010-10-02 06:53:11 +08:00
|
|
|
assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
|
2010-10-01 15:13:18 +08:00
|
|
|
"Integer constant 'I' type must be an integer");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
return Type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// GetBuiltinType - Return the type for the specified builtin.
|
2010-10-02 06:42:38 +08:00
|
|
|
QualType ASTContext::GetBuiltinType(unsigned Id,
|
2010-10-02 06:53:11 +08:00
|
|
|
GetBuiltinTypeError &Error,
|
|
|
|
unsigned *IntegerConstantArgs) {
|
2010-10-02 06:42:38 +08:00
|
|
|
const char *TypeStr = BuiltinInfo.GetTypeString(Id);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
llvm::SmallVector<QualType, 8> ArgTypes;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-10-02 06:53:11 +08:00
|
|
|
bool RequiresICE = false;
|
2009-06-14 08:45:47 +08:00
|
|
|
Error = GE_None;
|
2010-10-02 06:53:11 +08:00
|
|
|
QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
|
|
|
|
RequiresICE, true);
|
2009-06-14 08:45:47 +08:00
|
|
|
if (Error != GE_None)
|
|
|
|
return QualType();
|
2010-10-02 06:53:11 +08:00
|
|
|
|
|
|
|
assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE");
|
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
while (TypeStr[0] && TypeStr[0] != '.') {
|
2010-10-02 06:53:11 +08:00
|
|
|
QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
|
2009-06-14 08:45:47 +08:00
|
|
|
if (Error != GE_None)
|
|
|
|
return QualType();
|
|
|
|
|
2010-10-02 06:53:11 +08:00
|
|
|
// If this argument is required to be an IntegerConstantExpression and the
|
|
|
|
// caller cares, fill in the bitmask we return.
|
|
|
|
if (RequiresICE && IntegerConstantArgs)
|
|
|
|
*IntegerConstantArgs |= 1 << ArgTypes.size();
|
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
// Do array -> pointer decay. The builtin should use the decayed type.
|
|
|
|
if (Ty->isArrayType())
|
|
|
|
Ty = getArrayDecayedType(Ty);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-14 08:45:47 +08:00
|
|
|
ArgTypes.push_back(Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
|
|
|
|
"'.' should only occur at end of builtin type list!");
|
|
|
|
|
|
|
|
// handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);".
|
|
|
|
if (ArgTypes.size() == 0 && TypeStr[0] == '.')
|
|
|
|
return getFunctionNoProtoType(ResType);
|
2010-02-22 06:15:06 +08:00
|
|
|
|
|
|
|
// FIXME: Should we create noreturn types?
|
2009-06-14 08:45:47 +08:00
|
|
|
return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(),
|
2010-02-22 06:15:06 +08:00
|
|
|
TypeStr[0] == '.', 0, false, false, 0, 0,
|
2010-03-31 04:24:48 +08:00
|
|
|
FunctionType::ExtInfo());
|
2009-06-14 08:45:47 +08:00
|
|
|
}
|
2009-08-19 15:44:53 +08:00
|
|
|
|
|
|
|
QualType
|
|
|
|
ASTContext::UsualArithmeticConversionsType(QualType lhs, QualType rhs) {
|
|
|
|
// Perform the usual unary conversions. We do this early so that
|
|
|
|
// integral promotions to "int" can allow us to exit early, in the
|
|
|
|
// lhs == rhs check. Also, for conversion purposes, we ignore any
|
|
|
|
// qualifiers. For example, "const float" and "float" are
|
|
|
|
// equivalent.
|
|
|
|
if (lhs->isPromotableIntegerType())
|
|
|
|
lhs = getPromotedIntegerType(lhs);
|
|
|
|
else
|
|
|
|
lhs = lhs.getUnqualifiedType();
|
|
|
|
if (rhs->isPromotableIntegerType())
|
|
|
|
rhs = getPromotedIntegerType(rhs);
|
|
|
|
else
|
|
|
|
rhs = rhs.getUnqualifiedType();
|
|
|
|
|
|
|
|
// If both types are identical, no conversion is needed.
|
|
|
|
if (lhs == rhs)
|
|
|
|
return lhs;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-08-19 15:44:53 +08:00
|
|
|
// If either side is a non-arithmetic type (e.g. a pointer), we are done.
|
|
|
|
// The caller can deal with this (e.g. pointer + int).
|
|
|
|
if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
|
|
|
|
return lhs;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
// At this point, we have two different arithmetic types.
|
|
|
|
|
2009-08-19 15:44:53 +08:00
|
|
|
// Handle complex types first (C99 6.3.1.8p1).
|
|
|
|
if (lhs->isComplexType() || rhs->isComplexType()) {
|
|
|
|
// if we have an integer operand, the result is the complex type.
|
2009-09-09 23:08:12 +08:00
|
|
|
if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
|
2009-08-19 15:44:53 +08:00
|
|
|
// convert the rhs to the lhs complex type.
|
|
|
|
return lhs;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
|
2009-08-19 15:44:53 +08:00
|
|
|
// convert the lhs to the rhs complex type.
|
|
|
|
return rhs;
|
|
|
|
}
|
|
|
|
// This handles complex/complex, complex/float, or float/complex.
|
2009-09-09 23:08:12 +08:00
|
|
|
// When both operands are complex, the shorter operand is converted to the
|
|
|
|
// type of the longer, and that is the type of the result. This corresponds
|
|
|
|
// to what is done when combining two real floating-point operands.
|
|
|
|
// The fun begins when size promotion occur across type domains.
|
2009-08-19 15:44:53 +08:00
|
|
|
// From H&S 6.3.4: When one operand is complex and the other is a real
|
2009-09-09 23:08:12 +08:00
|
|
|
// floating-point type, the less precise type is converted, within it's
|
2009-08-19 15:44:53 +08:00
|
|
|
// real or complex domain, to the precision of the other type. For example,
|
2009-09-09 23:08:12 +08:00
|
|
|
// when combining a "long double" with a "double _Complex", the
|
2009-08-19 15:44:53 +08:00
|
|
|
// "double _Complex" is promoted to "long double _Complex".
|
|
|
|
int result = getFloatingTypeOrder(lhs, rhs);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
if (result > 0) { // The left side is bigger, convert rhs.
|
2009-08-19 15:44:53 +08:00
|
|
|
rhs = getFloatingTypeOfSizeWithinDomain(lhs, rhs);
|
2009-09-09 23:08:12 +08:00
|
|
|
} else if (result < 0) { // The right side is bigger, convert lhs.
|
2009-08-19 15:44:53 +08:00
|
|
|
lhs = getFloatingTypeOfSizeWithinDomain(rhs, lhs);
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
2009-08-19 15:44:53 +08:00
|
|
|
// At this point, lhs and rhs have the same rank/size. Now, make sure the
|
|
|
|
// domains match. This is a requirement for our implementation, C99
|
|
|
|
// does not require this promotion.
|
|
|
|
if (lhs != rhs) { // Domains don't match, we have complex/float mix.
|
|
|
|
if (lhs->isRealFloatingType()) { // handle "double, _Complex double".
|
|
|
|
return rhs;
|
|
|
|
} else { // handle "_Complex double, double".
|
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return lhs; // The domain/size match exactly.
|
|
|
|
}
|
|
|
|
// Now handle "real" floating types (i.e. float, double, long double).
|
|
|
|
if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) {
|
|
|
|
// if we have an integer operand, the result is the real floating type.
|
|
|
|
if (rhs->isIntegerType()) {
|
|
|
|
// convert rhs to the lhs floating point type.
|
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
if (rhs->isComplexIntegerType()) {
|
|
|
|
// convert rhs to the complex floating point type.
|
|
|
|
return getComplexType(lhs);
|
|
|
|
}
|
|
|
|
if (lhs->isIntegerType()) {
|
|
|
|
// convert lhs to the rhs floating point type.
|
|
|
|
return rhs;
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
if (lhs->isComplexIntegerType()) {
|
2009-08-19 15:44:53 +08:00
|
|
|
// convert lhs to the complex floating point type.
|
|
|
|
return getComplexType(rhs);
|
|
|
|
}
|
|
|
|
// We have two real floating types, float/complex combos were handled above.
|
|
|
|
// Convert the smaller operand to the bigger result.
|
|
|
|
int result = getFloatingTypeOrder(lhs, rhs);
|
|
|
|
if (result > 0) // convert the rhs
|
|
|
|
return lhs;
|
|
|
|
assert(result < 0 && "illegal float comparison");
|
|
|
|
return rhs; // convert the lhs
|
|
|
|
}
|
|
|
|
if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) {
|
|
|
|
// Handle GCC complex int extension.
|
|
|
|
const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
|
|
|
|
const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
|
|
|
|
|
|
|
|
if (lhsComplexInt && rhsComplexInt) {
|
2009-09-09 23:08:12 +08:00
|
|
|
if (getIntegerTypeOrder(lhsComplexInt->getElementType(),
|
2009-08-19 15:44:53 +08:00
|
|
|
rhsComplexInt->getElementType()) >= 0)
|
|
|
|
return lhs; // convert the rhs
|
|
|
|
return rhs;
|
|
|
|
} else if (lhsComplexInt && rhs->isIntegerType()) {
|
|
|
|
// convert the rhs to the lhs complex type.
|
|
|
|
return lhs;
|
|
|
|
} else if (rhsComplexInt && lhs->isIntegerType()) {
|
|
|
|
// convert the lhs to the rhs complex type.
|
|
|
|
return rhs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Finally, we have two differing integer types.
|
|
|
|
// The rules for this case are in C99 6.3.1.8
|
|
|
|
int compare = getIntegerTypeOrder(lhs, rhs);
|
2010-07-23 23:58:24 +08:00
|
|
|
bool lhsSigned = lhs->hasSignedIntegerRepresentation(),
|
|
|
|
rhsSigned = rhs->hasSignedIntegerRepresentation();
|
2009-08-19 15:44:53 +08:00
|
|
|
QualType destType;
|
|
|
|
if (lhsSigned == rhsSigned) {
|
|
|
|
// Same signedness; use the higher-ranked type
|
|
|
|
destType = compare >= 0 ? lhs : rhs;
|
|
|
|
} else if (compare != (lhsSigned ? 1 : -1)) {
|
|
|
|
// The unsigned type has greater than or equal rank to the
|
|
|
|
// signed type, so use the unsigned type
|
|
|
|
destType = lhsSigned ? rhs : lhs;
|
|
|
|
} else if (getIntWidth(lhs) != getIntWidth(rhs)) {
|
|
|
|
// The two types are different widths; if we are here, that
|
|
|
|
// means the signed type is larger than the unsigned type, so
|
|
|
|
// use the signed type.
|
|
|
|
destType = lhsSigned ? lhs : rhs;
|
|
|
|
} else {
|
|
|
|
// The signed type is higher-ranked than the unsigned type,
|
|
|
|
// but isn't actually any bigger (like unsigned int and long
|
|
|
|
// on most 32-bit systems). Use the unsigned type corresponding
|
|
|
|
// to the signed type.
|
|
|
|
destType = getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
|
|
|
|
}
|
|
|
|
return destType;
|
|
|
|
}
|
2010-07-30 02:15:58 +08:00
|
|
|
|
|
|
|
GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) {
|
|
|
|
GVALinkage External = GVA_StrongExternal;
|
|
|
|
|
|
|
|
Linkage L = FD->getLinkage();
|
|
|
|
if (L == ExternalLinkage && getLangOptions().CPlusPlus &&
|
|
|
|
FD->getType()->getLinkage() == UniqueExternalLinkage)
|
|
|
|
L = UniqueExternalLinkage;
|
|
|
|
|
|
|
|
switch (L) {
|
|
|
|
case NoLinkage:
|
|
|
|
case InternalLinkage:
|
|
|
|
case UniqueExternalLinkage:
|
|
|
|
return GVA_Internal;
|
|
|
|
|
|
|
|
case ExternalLinkage:
|
|
|
|
switch (FD->getTemplateSpecializationKind()) {
|
|
|
|
case TSK_Undeclared:
|
|
|
|
case TSK_ExplicitSpecialization:
|
|
|
|
External = GVA_StrongExternal;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TSK_ExplicitInstantiationDefinition:
|
|
|
|
return GVA_ExplicitTemplateInstantiation;
|
|
|
|
|
|
|
|
case TSK_ExplicitInstantiationDeclaration:
|
|
|
|
case TSK_ImplicitInstantiation:
|
|
|
|
External = GVA_TemplateInstantiation;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!FD->isInlined())
|
|
|
|
return External;
|
|
|
|
|
|
|
|
if (!getLangOptions().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) {
|
|
|
|
// GNU or C99 inline semantics. Determine whether this symbol should be
|
|
|
|
// externally visible.
|
|
|
|
if (FD->isInlineDefinitionExternallyVisible())
|
|
|
|
return External;
|
|
|
|
|
|
|
|
// C99 inline semantics, where the symbol is not externally visible.
|
|
|
|
return GVA_C99Inline;
|
|
|
|
}
|
|
|
|
|
|
|
|
// C++0x [temp.explicit]p9:
|
|
|
|
// [ Note: The intent is that an inline function that is the subject of
|
|
|
|
// an explicit instantiation declaration will still be implicitly
|
|
|
|
// instantiated when used so that the body can be considered for
|
|
|
|
// inlining, but that no out-of-line copy of the inline function would be
|
|
|
|
// generated in the translation unit. -- end note ]
|
|
|
|
if (FD->getTemplateSpecializationKind()
|
|
|
|
== TSK_ExplicitInstantiationDeclaration)
|
|
|
|
return GVA_C99Inline;
|
|
|
|
|
|
|
|
return GVA_CXXInline;
|
|
|
|
}
|
|
|
|
|
|
|
|
GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
|
|
|
|
// If this is a static data member, compute the kind of template
|
|
|
|
// specialization. Otherwise, this variable is not part of a
|
|
|
|
// template.
|
|
|
|
TemplateSpecializationKind TSK = TSK_Undeclared;
|
|
|
|
if (VD->isStaticDataMember())
|
|
|
|
TSK = VD->getTemplateSpecializationKind();
|
|
|
|
|
|
|
|
Linkage L = VD->getLinkage();
|
|
|
|
if (L == ExternalLinkage && getLangOptions().CPlusPlus &&
|
|
|
|
VD->getType()->getLinkage() == UniqueExternalLinkage)
|
|
|
|
L = UniqueExternalLinkage;
|
|
|
|
|
|
|
|
switch (L) {
|
|
|
|
case NoLinkage:
|
|
|
|
case InternalLinkage:
|
|
|
|
case UniqueExternalLinkage:
|
|
|
|
return GVA_Internal;
|
|
|
|
|
|
|
|
case ExternalLinkage:
|
|
|
|
switch (TSK) {
|
|
|
|
case TSK_Undeclared:
|
|
|
|
case TSK_ExplicitSpecialization:
|
|
|
|
return GVA_StrongExternal;
|
|
|
|
|
|
|
|
case TSK_ExplicitInstantiationDeclaration:
|
|
|
|
llvm_unreachable("Variable should not be instantiated");
|
|
|
|
// Fall through to treat this like any other instantiation.
|
|
|
|
|
|
|
|
case TSK_ExplicitInstantiationDefinition:
|
|
|
|
return GVA_ExplicitTemplateInstantiation;
|
|
|
|
|
|
|
|
case TSK_ImplicitInstantiation:
|
|
|
|
return GVA_TemplateInstantiation;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return GVA_StrongExternal;
|
|
|
|
}
|
|
|
|
|
2010-07-30 04:08:05 +08:00
|
|
|
bool ASTContext::DeclMustBeEmitted(const Decl *D) {
|
2010-07-30 02:15:58 +08:00
|
|
|
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
|
|
|
|
if (!VD->isFileVarDecl())
|
|
|
|
return false;
|
|
|
|
} else if (!isa<FunctionDecl>(D))
|
|
|
|
return false;
|
|
|
|
|
2010-07-30 04:07:52 +08:00
|
|
|
// Weak references don't produce any output by themselves.
|
|
|
|
if (D->hasAttr<WeakRefAttr>())
|
|
|
|
return false;
|
|
|
|
|
2010-07-30 02:15:58 +08:00
|
|
|
// Aliases and used decls are required.
|
|
|
|
if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
|
|
|
|
// Forward declarations aren't required.
|
|
|
|
if (!FD->isThisDeclarationADefinition())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Constructors and destructors are required.
|
|
|
|
if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// The key function for a class is required.
|
|
|
|
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
|
|
|
|
const CXXRecordDecl *RD = MD->getParent();
|
|
|
|
if (MD->isOutOfLine() && RD->isDynamicClass()) {
|
|
|
|
const CXXMethodDecl *KeyFunc = getKeyFunction(RD);
|
|
|
|
if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
GVALinkage Linkage = GetGVALinkageForFunction(FD);
|
|
|
|
|
|
|
|
// static, static inline, always_inline, and extern inline functions can
|
|
|
|
// always be deferred. Normal inline functions can be deferred in C99/C++.
|
|
|
|
// Implicit template instantiations can also be deferred in C++.
|
|
|
|
if (Linkage == GVA_Internal || Linkage == GVA_C99Inline ||
|
|
|
|
Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VarDecl *VD = cast<VarDecl>(D);
|
|
|
|
assert(VD->isFileVarDecl() && "Expected file scoped var");
|
|
|
|
|
2010-07-30 04:07:52 +08:00
|
|
|
if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly)
|
|
|
|
return false;
|
|
|
|
|
2010-07-30 02:15:58 +08:00
|
|
|
// Structs that have non-trivial constructors or destructors are required.
|
|
|
|
|
|
|
|
// FIXME: Handle references.
|
|
|
|
if (const RecordType *RT = VD->getType()->getAs<RecordType>()) {
|
|
|
|
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
|
2010-08-15 09:15:20 +08:00
|
|
|
if (RD->hasDefinition() &&
|
|
|
|
(!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor()))
|
2010-07-30 02:15:58 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
GVALinkage L = GetGVALinkageForVariable(VD);
|
|
|
|
if (L == GVA_Internal || L == GVA_TemplateInstantiation) {
|
|
|
|
if (!(VD->getInit() && VD->getInit()->HasSideEffects(*this)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2010-08-16 11:33:14 +08:00
|
|
|
|
|
|
|
CXXABI::~CXXABI() {}
|