Unifies the name-lookup mechanisms used in various parts of the AST
and separates lexical name lookup from qualified name lookup. In
particular:
* Make DeclContext the central data structure for storing and
looking up declarations within existing declarations, e.g., members
of structs/unions/classes, enumerators in C++0x enums, members of
C++ namespaces, and (later) members of Objective-C
interfaces/implementations. DeclContext uses a lazily-constructed
data structure optimized for fast lookup (array for small contexts,
hash table for larger contexts).
* Implement C++ qualified name lookup in terms of lookup into
DeclContext.
* Implement C++ unqualified name lookup in terms of
qualified+unqualified name lookup (since unqualified lookup is not
purely lexical in C++!)
* Limit the use of the chains of declarations stored in
IdentifierInfo to those names declared lexically.
* Eliminate CXXFieldDecl, collapsing its behavior into
FieldDecl. (FieldDecl is now a ScopedDecl).
* Make RecordDecl into a DeclContext and eliminates its
Members/NumMembers fields (since one can just iterate through the
DeclContext to get the fields).
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60878 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp
index d93bccd..67c60aa 100644
--- a/lib/CodeGen/CGDebugInfo.cpp
+++ b/lib/CodeGen/CGDebugInfo.cpp
@@ -289,10 +289,11 @@
llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators;
// Create DIEnumerator elements for each enumerator.
- for (EnumConstantDecl *Elt = Decl->getEnumConstantList(); Elt;
- Elt = dyn_cast_or_null<EnumConstantDecl>(Elt->getNextDeclarator())) {
- Enumerators.push_back(DebugFactory.CreateEnumerator(Elt->getNameAsString(),
- Elt->getInitVal().getZExtValue()));
+ for (EnumDecl::enumerator_iterator Enum = Decl->enumerator_begin(),
+ EnumEnd = Decl->enumerator_end();
+ Enum != EnumEnd; ++Enum) {
+ Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getNameAsString(),
+ Enum->getInitVal().getZExtValue()));
}
// Return a CompositeType for the enum itself.
diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 65f8a1a..834d748 100644
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -434,20 +434,24 @@
// the optimizer, especially with bitfields.
unsigned NumInitElements = E->getNumInits();
RecordDecl *SD = E->getType()->getAsRecordType()->getDecl();
- unsigned NumMembers = SD->getNumMembers() - SD->hasFlexibleArrayMember();
unsigned CurInitVal = 0;
bool isUnion = E->getType()->isUnionType();
// Here we iterate over the fields; this makes it simpler to both
// default-initialize fields and skip over unnamed fields.
- for (unsigned CurFieldNo = 0; CurFieldNo != NumMembers; ++CurFieldNo) {
- FieldDecl *CurField = SD->getMember(CurFieldNo);
- if (CurField->getIdentifier() == 0) {
+ for (RecordDecl::field_iterator Field = SD->field_begin(),
+ FieldEnd = SD->field_end();
+ Field != FieldEnd; ++Field) {
+ // We're done once we hit the flexible array member
+ if (Field->getType()->isIncompleteArrayType())
+ break;
+
+ if (Field->getIdentifier() == 0) {
// Initializers can't initialize unnamed fields, e.g. "int : 20;"
continue;
}
// FIXME: volatility
- LValue FieldLoc = CGF.EmitLValueForField(DestPtr, CurField, isUnion,0);
+ LValue FieldLoc = CGF.EmitLValueForField(DestPtr, *Field, isUnion,0);
if (CurInitVal < NumInitElements) {
// Store the initializer into the field
// This will probably have to get a bit smarter when we support
@@ -455,7 +459,7 @@
EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc);
} else {
// We're out of initalizers; default-initialize to null
- EmitNullInitializationToLValue(FieldLoc, CurField->getType());
+ EmitNullInitializationToLValue(FieldLoc, Field->getType());
}
// Unions only initialize one field.
diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index 7f294e2..52d99dc 100644
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -187,16 +187,17 @@
unsigned EltNo = 0; // Element no in ILE
int FieldNo = 0; // Field no in RecordDecl
bool RewriteType = false;
- while (EltNo < ILE->getNumInits() && FieldNo < RD->getNumMembers()) {
- FieldDecl* curField = RD->getMember(FieldNo);
+ for (RecordDecl::field_iterator Field = RD->field_begin(),
+ FieldEnd = RD->field_end();
+ EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) {
FieldNo++;
- if (!curField->getIdentifier())
+ if (!Field->getIdentifier())
continue;
- if (curField->isBitField()) {
- InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(EltNo));
+ if (Field->isBitField()) {
+ InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo));
} else {
- unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(curField);
+ unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field);
llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF);
RewriteType |= (C->getType() != Elts[FieldNo]->getType());
Elts[FieldNo] = C;
@@ -223,8 +224,10 @@
// Find the field decl we're initializing, if any
int FieldNo = 0; // Field no in RecordDecl
FieldDecl* curField = 0;
- while (FieldNo < RD->getNumMembers()) {
- curField = RD->getMember(FieldNo);
+ for (RecordDecl::field_iterator Field = RD->field_begin(),
+ FieldEnd = RD->field_end();
+ Field != FieldEnd; ++Field) {
+ curField = *Field;
FieldNo++;
if (curField->getIdentifier())
break;
diff --git a/lib/CodeGen/CGObjCMac.cpp b/lib/CodeGen/CGObjCMac.cpp
index 013b0f9..201f53e 100644
--- a/lib/CodeGen/CGObjCMac.cpp
+++ b/lib/CodeGen/CGObjCMac.cpp
@@ -2373,12 +2373,15 @@
RecordDecl *RD = RecordDecl::Create(Ctx, TagDecl::TK_struct, 0,
SourceLocation(),
&Ctx.Idents.get("_objc_super"));
- FieldDecl *FieldDecls[2];
- FieldDecls[0] = FieldDecl::Create(Ctx, SourceLocation(), 0,
- Ctx.getObjCIdType());
- FieldDecls[1] = FieldDecl::Create(Ctx, SourceLocation(), 0,
- Ctx.getObjCClassType());
- RD->defineBody(Ctx, FieldDecls, 2);
+ RD->addDecl(Ctx,
+ FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
+ Ctx.getObjCIdType(), 0, false, 0),
+ true);
+ RD->addDecl(Ctx,
+ FieldDecl::Create(Ctx, RD, SourceLocation(), 0,
+ Ctx.getObjCClassType(), 0, false, 0),
+ true);
+ RD->completeDefinition(Ctx);
SuperCTy = Ctx.getTagDeclType(RD);
SuperPtrCTy = Ctx.getPointerType(SuperCTy);
diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp
index 82e7321..e83d2cd 100644
--- a/lib/CodeGen/CodeGenModule.cpp
+++ b/lib/CodeGen/CodeGenModule.cpp
@@ -775,21 +775,20 @@
static void appendFieldAndPadding(CodeGenModule &CGM,
std::vector<llvm::Constant*>& Fields,
- int FieldNo, llvm::Constant* Field,
+ FieldDecl *FieldD, FieldDecl *NextFieldD,
+ llvm::Constant* Field,
RecordDecl* RD, const llvm::StructType *STy)
{
// Append the field.
Fields.push_back(Field);
- int StructFieldNo =
- CGM.getTypes().getLLVMFieldNo(RD->getMember(FieldNo));
+ int StructFieldNo = CGM.getTypes().getLLVMFieldNo(FieldD);
int NextStructFieldNo;
- if (FieldNo + 1 == RD->getNumMembers()) {
+ if (!NextFieldD) {
NextStructFieldNo = STy->getNumElements();
} else {
- NextStructFieldNo =
- CGM.getTypes().getLLVMFieldNo(RD->getMember(FieldNo + 1));
+ NextStructFieldNo = CGM.getTypes().getLLVMFieldNo(NextFieldD);
}
// Append padding
@@ -841,29 +840,38 @@
cast<llvm::StructType>(getTypes().ConvertType(CFTy));
std::vector<llvm::Constant*> Fields;
-
-
+ RecordDecl::field_iterator Field = CFRD->field_begin();
+
// Class pointer.
- appendFieldAndPadding(*this, Fields, 0, CFConstantStringClassRef, CFRD, STy);
+ FieldDecl *CurField = *Field++;
+ FieldDecl *NextField = *Field++;
+ appendFieldAndPadding(*this, Fields, CurField, NextField,
+ CFConstantStringClassRef, CFRD, STy);
// Flags.
+ CurField = NextField;
+ NextField = *Field++;
const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
- appendFieldAndPadding(*this, Fields, 1, llvm::ConstantInt::get(Ty, 0x07C8),
- CFRD, STy);
+ appendFieldAndPadding(*this, Fields, CurField, NextField,
+ llvm::ConstantInt::get(Ty, 0x07C8), CFRD, STy);
// String pointer.
+ CurField = NextField;
+ NextField = *Field++;
llvm::Constant *C = llvm::ConstantArray::get(str);
C = new llvm::GlobalVariable(C->getType(), true,
llvm::GlobalValue::InternalLinkage,
C, ".str", &getModule());
- appendFieldAndPadding(*this, Fields, 2,
+ appendFieldAndPadding(*this, Fields, CurField, NextField,
llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2),
CFRD, STy);
// String length.
+ CurField = NextField;
+ NextField = 0;
Ty = getTypes().ConvertType(getContext().LongTy);
- appendFieldAndPadding(*this, Fields, 3, llvm::ConstantInt::get(Ty, str.length()),
- CFRD, STy);
+ appendFieldAndPadding(*this, Fields, CurField, NextField,
+ llvm::ConstantInt::get(Ty, str.length()), CFRD, STy);
// The struct.
C = llvm::ConstantStruct::get(STy, Fields);
diff --git a/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp
index 85b1039..8918671 100644
--- a/lib/CodeGen/CodeGenTypes.cpp
+++ b/lib/CodeGen/CodeGenTypes.cpp
@@ -392,7 +392,7 @@
} else if (TD->isUnion()) {
// Just use the largest element of the union, breaking ties with the
// highest aligned member.
- if (RD->getNumMembers() != 0) {
+ if (RD->field_begin() != RD->field_end()) {
RecordOrganizer RO(*this, *RD);
RO.layoutUnionFields(Context.getASTRecordLayout(RD));
@@ -478,16 +478,17 @@
uint64_t llvmSize = 0;
// FIXME: Make this a SmallVector
std::vector<const llvm::Type*> LLVMFields;
- int NumMembers = RD.getNumMembers();
- for (int curField = 0; curField < NumMembers; curField++) {
- const FieldDecl *FD = RD.getMember(curField);
+ unsigned curField = 0;
+ for (RecordDecl::field_iterator Field = RD.field_begin(),
+ FieldEnd = RD.field_end();
+ Field != FieldEnd; ++Field) {
uint64_t offset = RL.getFieldOffset(curField);
- const llvm::Type *Ty = CGT.ConvertTypeRecursive(FD->getType());
+ const llvm::Type *Ty = CGT.ConvertTypeRecursive(Field->getType());
uint64_t size = CGT.getTargetData().getABITypeSizeInBits(Ty);
- if (FD->isBitField()) {
- Expr *BitWidth = FD->getBitWidth();
+ if (Field->isBitField()) {
+ Expr *BitWidth = Field->getBitWidth();
llvm::APSInt FieldSize(32);
bool isBitField =
BitWidth->isIntegerConstantExpr(FieldSize, CGT.getContext());
@@ -498,8 +499,8 @@
// Bitfield field info is different from other field info;
// it actually ignores the underlying LLVM struct because
// there isn't any convenient mapping.
- CGT.addFieldInfo(FD, offset / size);
- CGT.addBitFieldInfo(FD, offset % size, BitFieldSize);
+ CGT.addFieldInfo(*Field, offset / size);
+ CGT.addBitFieldInfo(*Field, offset % size, BitFieldSize);
} else {
// Put the element into the struct. This would be simpler
// if we didn't bother, but it seems a bit too strange to
@@ -510,9 +511,10 @@
}
llvmSize += size;
- CGT.addFieldInfo(FD, LLVMFields.size());
+ CGT.addFieldInfo(*Field, LLVMFields.size());
LLVMFields.push_back(Ty);
}
+ ++curField;
}
while (llvmSize < RL.getSize()) {
@@ -528,21 +530,24 @@
/// corresponding llvm struct type. This should be invoked only after
/// all fields are added.
void RecordOrganizer::layoutUnionFields(const ASTRecordLayout &RL) {
- for (int curField = 0; curField < RD.getNumMembers(); curField++) {
- const FieldDecl *FD = RD.getMember(curField);
+ unsigned curField = 0;
+ for (RecordDecl::field_iterator Field = RD.field_begin(),
+ FieldEnd = RD.field_end();
+ Field != FieldEnd; ++Field) {
// The offset should usually be zero, but bitfields could be strange
uint64_t offset = RL.getFieldOffset(curField);
- if (FD->isBitField()) {
- Expr *BitWidth = FD->getBitWidth();
+ if (Field->isBitField()) {
+ Expr *BitWidth = Field->getBitWidth();
uint64_t BitFieldSize =
BitWidth->getIntegerConstantExprValue(CGT.getContext()).getZExtValue();
- CGT.addFieldInfo(FD, 0);
- CGT.addBitFieldInfo(FD, offset, BitFieldSize);
+ CGT.addFieldInfo(*Field, 0);
+ CGT.addBitFieldInfo(*Field, offset, BitFieldSize);
} else {
- CGT.addFieldInfo(FD, 0);
+ CGT.addFieldInfo(*Field, 0);
}
+ ++curField;
}
// This looks stupid, but it is correct in the sense that