replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Factor out routines to encode/decode DeclaratorInfos and move them into the 

core PCH reader/writer implementation files.

llvm-svn: 84278
This commit is contained in:
John McCall 2009-10-16 21:56:05 +00:00
parent ff47031601
commit 8f115c6b45
6 changed files with 170 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clang/include/clang/Frontend/PCHReader.h
View File

@ -542,6 +542,10 @@ public:
/// comments in the source code.
virtual void ReadComments(std::vector<SourceRange> &Comments);
/// \brief Reads a declarator info from the given record.
virtual DeclaratorInfo *GetDeclaratorInfo(const RecordData &Record,
unsigned &Idx);
/// \brief Resolve a type ID into a type, potentially building a new
/// type.
virtual QualType GetType(pch::TypeID ID);

3
clang/include/clang/Frontend/PCHWriter.h
View File

@ -254,6 +254,9 @@ public:
/// \brief Emit a reference to a type.
void AddTypeRef(QualType T, RecordData &Record);
/// \brief Emits a reference to a declarator info.
void AddDeclaratorInfo(DeclaratorInfo *DInfo, RecordData &Record);
/// \brief Emit a reference to a declaration.
void AddDeclRef(const Decl *D, RecordData &Record);

80
clang/lib/Frontend/PCHReader.cpp
View File

@ -18,6 +18,7 @@
#include "clang/AST/ASTContext.h"
#include "clang/AST/Expr.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLocVisitor.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Lex/HeaderSearch.h"
@ -1979,6 +1980,85 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) {
return QualType();
}
namespace {
class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
PCHReader &Reader;
const PCHReader::RecordData &Record;
unsigned &Idx;
public:
TypeLocReader(PCHReader &Reader, const PCHReader::RecordData &Record,
unsigned &Idx)
: Reader(Reader), Record(Record), Idx(Idx) { }
#define ABSTRACT_TYPELOC(CLASS)
#define TYPELOC(CLASS, PARENT) \
void Visit##CLASS(CLASS TyLoc);
#include "clang/AST/TypeLocNodes.def"
void VisitTypeLoc(TypeLoc TyLoc) {
assert(0 && "A type loc wrapper was not handled!");
}
};
}
void TypeLocReader::VisitQualifiedLoc(QualifiedLoc TyLoc) {
// nothing to do
}
void TypeLocReader::VisitDefaultTypeSpecLoc(DefaultTypeSpecLoc TyLoc) {
TyLoc.setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitTypedefLoc(TypedefLoc TyLoc) {
TyLoc.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitObjCInterfaceLoc(ObjCInterfaceLoc TyLoc) {
TyLoc.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitObjCProtocolListLoc(ObjCProtocolListLoc TyLoc) {
TyLoc.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TyLoc.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TyLoc.getNumProtocols(); i != e; ++i)
TyLoc.setProtocolLoc(i, SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitPointerLoc(PointerLoc TyLoc) {
TyLoc.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitBlockPointerLoc(BlockPointerLoc TyLoc) {
TyLoc.setCaretLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitMemberPointerLoc(MemberPointerLoc TyLoc) {
TyLoc.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitReferenceLoc(ReferenceLoc TyLoc) {
TyLoc.setAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitFunctionLoc(FunctionLoc TyLoc) {
TyLoc.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TyLoc.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TyLoc.getNumArgs(); i != e; ++i)
TyLoc.setArg(i, cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
}
void TypeLocReader::VisitArrayLoc(ArrayLoc TyLoc) {
TyLoc.setLBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TyLoc.setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
if (Record[Idx++])
TyLoc.setSizeExpr(Reader.ReadDeclExpr());
}
DeclaratorInfo *PCHReader::GetDeclaratorInfo(const RecordData &Record,
unsigned &Idx) {
QualType InfoTy = GetType(Record[Idx++]);
if (InfoTy.isNull())
return 0;
DeclaratorInfo *DInfo = getContext()->CreateDeclaratorInfo(InfoTy);
TypeLocReader TLR(*this, Record, Idx);
for (TypeLoc TL = DInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
TLR.Visit(TL);
return DInfo;
}
QualType PCHReader::GetType(pch::TypeID ID) {
unsigned FastQuals = ID & Qualifiers::FastMask;

80
clang/lib/Frontend/PCHReaderDecl.cpp
View File

@ -18,7 +18,6 @@
#include "clang/AST/DeclVisitor.h"
#include "clang/AST/DeclGroup.h"
#include "clang/AST/Expr.h"
#include "clang/AST/TypeLocVisitor.h"
using namespace clang;
@ -150,84 +149,11 @@ void PCHDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
}
namespace {
class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
PCHReader &Reader;
const PCHReader::RecordData &Record;
unsigned &Idx;
public:
TypeLocReader(PCHReader &Reader, const PCHReader::RecordData &Record,
unsigned &Idx)
: Reader(Reader), Record(Record), Idx(Idx) { }
#define ABSTRACT_TYPELOC(CLASS)
#define TYPELOC(CLASS, PARENT) \
void Visit##CLASS(CLASS TyLoc);
#include "clang/AST/TypeLocNodes.def"
void VisitTypeLoc(TypeLoc TyLoc) {
assert(0 && "A type loc wrapper was not handled!");
}
};
}
void TypeLocReader::VisitQualifiedLoc(QualifiedLoc TyLoc) {
// nothing to do
}
void TypeLocReader::VisitDefaultTypeSpecLoc(DefaultTypeSpecLoc TyLoc) {
TyLoc.setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitTypedefLoc(TypedefLoc TyLoc) {
TyLoc.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitObjCInterfaceLoc(ObjCInterfaceLoc TyLoc) {
TyLoc.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitObjCProtocolListLoc(ObjCProtocolListLoc TyLoc) {
TyLoc.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TyLoc.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TyLoc.getNumProtocols(); i != e; ++i)
TyLoc.setProtocolLoc(i, SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitPointerLoc(PointerLoc TyLoc) {
TyLoc.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitBlockPointerLoc(BlockPointerLoc TyLoc) {
TyLoc.setCaretLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitMemberPointerLoc(MemberPointerLoc TyLoc) {
TyLoc.setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitReferenceLoc(ReferenceLoc TyLoc) {
TyLoc.setAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitFunctionLoc(FunctionLoc TyLoc) {
TyLoc.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TyLoc.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TyLoc.getNumArgs(); i != e; ++i)
TyLoc.setArg(i, cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
}
void TypeLocReader::VisitArrayLoc(ArrayLoc TyLoc) {
TyLoc.setLBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TyLoc.setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
if (Record[Idx++])
TyLoc.setSizeExpr(Reader.ReadDeclExpr());
}
void PCHDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
VisitValueDecl(DD);
QualType InfoTy = Reader.GetType(Record[Idx++]);
if (InfoTy.isNull())
return;
DeclaratorInfo *DInfo = Reader.getContext()->CreateDeclaratorInfo(InfoTy);
TypeLocReader TLR(Reader, Record, Idx);
for (TypeLoc TL = DInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
TLR.Visit(TL);
DD->setDeclaratorInfo(DInfo);
DeclaratorInfo *DInfo = Reader.GetDeclaratorInfo(Record, Idx);
if (DInfo)
DD->setDeclaratorInfo(DInfo);
}
void PCHDeclReader::VisitFunctionDecl(FunctionDecl *FD) {

79
clang/lib/Frontend/PCHWriter.cpp
View File

@ -19,6 +19,7 @@
#include "clang/AST/DeclContextInternals.h"
#include "clang/AST/Expr.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLocVisitor.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Lex/HeaderSearch.h"
@ -247,6 +248,72 @@ void PCHTypeWriter::VisitObjCProtocolListType(const ObjCProtocolListType *T) {
Code = pch::TYPE_OBJC_PROTOCOL_LIST;
}
namespace {
class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
PCHWriter &Writer;
PCHWriter::RecordData &Record;
public:
TypeLocWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
: Writer(Writer), Record(Record) { }
#define ABSTRACT_TYPELOC(CLASS)
#define TYPELOC(CLASS, PARENT) \
void Visit##CLASS(CLASS TyLoc);
#include "clang/AST/TypeLocNodes.def"
void VisitTypeLoc(TypeLoc TyLoc) {
assert(0 && "A type loc wrapper was not handled!");
}
};
}
void TypeLocWriter::VisitQualifiedLoc(QualifiedLoc TyLoc) {
// nothing to do here
}
void TypeLocWriter::VisitDefaultTypeSpecLoc(DefaultTypeSpecLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getStartLoc(), Record);
}
void TypeLocWriter::VisitTypedefLoc(TypedefLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getNameLoc(), Record);
}
void TypeLocWriter::VisitObjCInterfaceLoc(ObjCInterfaceLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getNameLoc(), Record);
}
void TypeLocWriter::VisitObjCProtocolListLoc(ObjCProtocolListLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getLAngleLoc(), Record);
Writer.AddSourceLocation(TyLoc.getRAngleLoc(), Record);
for (unsigned i = 0, e = TyLoc.getNumProtocols(); i != e; ++i)
Writer.AddSourceLocation(TyLoc.getProtocolLoc(i), Record);
}
void TypeLocWriter::VisitPointerLoc(PointerLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getStarLoc(), Record);
}
void TypeLocWriter::VisitBlockPointerLoc(BlockPointerLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getCaretLoc(), Record);
}
void TypeLocWriter::VisitMemberPointerLoc(MemberPointerLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getStarLoc(), Record);
}
void TypeLocWriter::VisitReferenceLoc(ReferenceLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getAmpLoc(), Record);
}
void TypeLocWriter::VisitFunctionLoc(FunctionLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getLParenLoc(), Record);
Writer.AddSourceLocation(TyLoc.getRParenLoc(), Record);
for (unsigned i = 0, e = TyLoc.getNumArgs(); i != e; ++i)
Writer.AddDeclRef(TyLoc.getArg(i), Record);
}
void TypeLocWriter::VisitArrayLoc(ArrayLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getLBracketLoc(), Record);
Writer.AddSourceLocation(TyLoc.getRBracketLoc(), Record);
Record.push_back(TyLoc.getSizeExpr() ? 1 : 0);
if (TyLoc.getSizeExpr())
Writer.AddStmt(TyLoc.getSizeExpr());
}
//===----------------------------------------------------------------------===//
// PCHWriter Implementation
//===----------------------------------------------------------------------===//
@ -1974,6 +2041,18 @@ void PCHWriter::AddSelectorRef(const Selector SelRef, RecordData &Record) {
Record.push_back(SID);
}
void PCHWriter::AddDeclaratorInfo(DeclaratorInfo *DInfo, RecordData &Record) {
if (DInfo == 0) {
AddTypeRef(QualType(), Record);
return;
}
AddTypeRef(DInfo->getTypeLoc().getSourceType(), Record);
TypeLocWriter TLW(*this, Record);
for (TypeLoc TL = DInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
TLW.Visit(TL);
}
void PCHWriter::AddTypeRef(QualType T, RecordData &Record) {
if (T.isNull()) {
Record.push_back(pch::PREDEF_TYPE_NULL_ID);

77
clang/lib/Frontend/PCHWriterDecl.cpp
View File

@ -14,7 +14,6 @@
#include "clang/Frontend/PCHWriter.h"
#include "clang/AST/DeclVisitor.h"
#include "clang/AST/Expr.h"
#include "clang/AST/TypeLocVisitor.h"
#include "llvm/Bitcode/BitstreamWriter.h"
#include <cstdio>
@ -150,84 +149,10 @@ void PCHDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
Writer.AddAPSInt(D->getInitVal(), Record);
Code = pch::DECL_ENUM_CONSTANT;
}
namespace {
class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
PCHWriter &Writer;
PCHWriter::RecordData &Record;
public:
TypeLocWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
: Writer(Writer), Record(Record) { }
#define ABSTRACT_TYPELOC(CLASS)
#define TYPELOC(CLASS, PARENT) \
void Visit##CLASS(CLASS TyLoc);
#include "clang/AST/TypeLocNodes.def"
void VisitTypeLoc(TypeLoc TyLoc) {
assert(0 && "A type loc wrapper was not handled!");
}
};
}
void TypeLocWriter::VisitQualifiedLoc(QualifiedLoc TyLoc) {
// nothing to do here
}
void TypeLocWriter::VisitDefaultTypeSpecLoc(DefaultTypeSpecLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getStartLoc(), Record);
}
void TypeLocWriter::VisitTypedefLoc(TypedefLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getNameLoc(), Record);
}
void TypeLocWriter::VisitObjCInterfaceLoc(ObjCInterfaceLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getNameLoc(), Record);
}
void TypeLocWriter::VisitObjCProtocolListLoc(ObjCProtocolListLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getLAngleLoc(), Record);
Writer.AddSourceLocation(TyLoc.getRAngleLoc(), Record);
for (unsigned i = 0, e = TyLoc.getNumProtocols(); i != e; ++i)
Writer.AddSourceLocation(TyLoc.getProtocolLoc(i), Record);
}
void TypeLocWriter::VisitPointerLoc(PointerLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getStarLoc(), Record);
}
void TypeLocWriter::VisitBlockPointerLoc(BlockPointerLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getCaretLoc(), Record);
}
void TypeLocWriter::VisitMemberPointerLoc(MemberPointerLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getStarLoc(), Record);
}
void TypeLocWriter::VisitReferenceLoc(ReferenceLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getAmpLoc(), Record);
}
void TypeLocWriter::VisitFunctionLoc(FunctionLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getLParenLoc(), Record);
Writer.AddSourceLocation(TyLoc.getRParenLoc(), Record);
for (unsigned i = 0, e = TyLoc.getNumArgs(); i != e; ++i)
Writer.AddDeclRef(TyLoc.getArg(i), Record);
}
void TypeLocWriter::VisitArrayLoc(ArrayLoc TyLoc) {
Writer.AddSourceLocation(TyLoc.getLBracketLoc(), Record);
Writer.AddSourceLocation(TyLoc.getRBracketLoc(), Record);
Record.push_back(TyLoc.getSizeExpr() ? 1 : 0);
if (TyLoc.getSizeExpr())
Writer.AddStmt(TyLoc.getSizeExpr());
}
void PCHDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
VisitValueDecl(D);
DeclaratorInfo *DInfo = D->getDeclaratorInfo();
if (DInfo == 0) {
Writer.AddTypeRef(QualType(), Record);
return;
}
Writer.AddTypeRef(DInfo->getTypeLoc().getSourceType(), Record);
TypeLocWriter TLW(Writer, Record);
for (TypeLoc TL = DInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
TLW.Visit(TL);
Writer.AddDeclaratorInfo(D->getDeclaratorInfo(), Record);
}
void PCHDeclWriter::VisitFunctionDecl(FunctionDecl *D) {