2009-04-10 02:27:44 +04:00
|
|
|
//===--- PCHReader.cpp - Precompiled Headers Reader -------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines the PCHReader class, which reads a precompiled header.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Frontend/PCHReader.h"
|
2009-04-11 00:39:37 +04:00
|
|
|
#include "clang/Frontend/FrontendDiagnostic.h"
|
2009-04-14 04:24:19 +04:00
|
|
|
#include "clang/AST/ASTConsumer.h"
|
2009-04-10 02:27:44 +04:00
|
|
|
#include "clang/AST/ASTContext.h"
|
|
|
|
#include "clang/AST/Decl.h"
|
2009-04-14 04:24:19 +04:00
|
|
|
#include "clang/AST/DeclGroup.h"
|
2009-04-17 02:29:51 +04:00
|
|
|
#include "clang/AST/DeclVisitor.h"
|
2009-04-15 01:18:50 +04:00
|
|
|
#include "clang/AST/Expr.h"
|
|
|
|
#include "clang/AST/StmtVisitor.h"
|
2009-04-10 02:27:44 +04:00
|
|
|
#include "clang/AST/Type.h"
|
2009-04-11 01:41:48 +04:00
|
|
|
#include "clang/Lex/MacroInfo.h"
|
2009-04-10 07:52:48 +04:00
|
|
|
#include "clang/Lex/Preprocessor.h"
|
|
|
|
#include "clang/Basic/SourceManager.h"
|
2009-04-13 20:31:14 +04:00
|
|
|
#include "clang/Basic/SourceManagerInternals.h"
|
2009-04-10 07:52:48 +04:00
|
|
|
#include "clang/Basic/FileManager.h"
|
2009-04-11 01:16:55 +04:00
|
|
|
#include "clang/Basic/TargetInfo.h"
|
2009-04-10 02:27:44 +04:00
|
|
|
#include "llvm/Bitcode/BitstreamReader.h"
|
|
|
|
#include "llvm/Support/Compiler.h"
|
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <cstdio>
|
|
|
|
|
|
|
|
using namespace clang;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Declaration deserialization
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
2009-04-17 02:29:51 +04:00
|
|
|
class VISIBILITY_HIDDEN PCHDeclReader
|
|
|
|
: public DeclVisitor<PCHDeclReader, void> {
|
2009-04-10 02:27:44 +04:00
|
|
|
PCHReader &Reader;
|
|
|
|
const PCHReader::RecordData &Record;
|
|
|
|
unsigned &Idx;
|
|
|
|
|
|
|
|
public:
|
|
|
|
PCHDeclReader(PCHReader &Reader, const PCHReader::RecordData &Record,
|
|
|
|
unsigned &Idx)
|
|
|
|
: Reader(Reader), Record(Record), Idx(Idx) { }
|
|
|
|
|
|
|
|
void VisitDecl(Decl *D);
|
|
|
|
void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
|
|
|
|
void VisitNamedDecl(NamedDecl *ND);
|
|
|
|
void VisitTypeDecl(TypeDecl *TD);
|
|
|
|
void VisitTypedefDecl(TypedefDecl *TD);
|
2009-04-13 22:14:40 +04:00
|
|
|
void VisitTagDecl(TagDecl *TD);
|
|
|
|
void VisitEnumDecl(EnumDecl *ED);
|
2009-04-14 01:20:57 +04:00
|
|
|
void VisitRecordDecl(RecordDecl *RD);
|
2009-04-10 02:27:44 +04:00
|
|
|
void VisitValueDecl(ValueDecl *VD);
|
2009-04-13 22:14:40 +04:00
|
|
|
void VisitEnumConstantDecl(EnumConstantDecl *ECD);
|
2009-04-14 02:18:37 +04:00
|
|
|
void VisitFunctionDecl(FunctionDecl *FD);
|
2009-04-14 01:20:57 +04:00
|
|
|
void VisitFieldDecl(FieldDecl *FD);
|
2009-04-10 02:27:44 +04:00
|
|
|
void VisitVarDecl(VarDecl *VD);
|
2009-04-14 02:18:37 +04:00
|
|
|
void VisitParmVarDecl(ParmVarDecl *PD);
|
|
|
|
void VisitOriginalParmVarDecl(OriginalParmVarDecl *PD);
|
2009-04-14 02:49:25 +04:00
|
|
|
void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
|
|
|
|
void VisitBlockDecl(BlockDecl *BD);
|
2009-04-10 02:27:44 +04:00
|
|
|
std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitDecl(Decl *D) {
|
|
|
|
D->setDeclContext(cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
D->setLexicalDeclContext(
|
|
|
|
cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
D->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
D->setInvalidDecl(Record[Idx++]);
|
2009-04-16 01:30:51 +04:00
|
|
|
if (Record[Idx++])
|
|
|
|
D->addAttr(Reader.ReadAttributes());
|
2009-04-10 02:27:44 +04:00
|
|
|
D->setImplicit(Record[Idx++]);
|
|
|
|
D->setAccess((AccessSpecifier)Record[Idx++]);
|
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
|
|
|
|
VisitDecl(TU);
|
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitNamedDecl(NamedDecl *ND) {
|
|
|
|
VisitDecl(ND);
|
|
|
|
ND->setDeclName(Reader.ReadDeclarationName(Record, Idx));
|
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitTypeDecl(TypeDecl *TD) {
|
|
|
|
VisitNamedDecl(TD);
|
|
|
|
TD->setTypeForDecl(Reader.GetType(Record[Idx++]).getTypePtr());
|
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
|
2009-04-14 00:46:52 +04:00
|
|
|
// Note that we cannot use VisitTypeDecl here, because we need to
|
|
|
|
// set the underlying type of the typedef *before* we try to read
|
|
|
|
// the type associated with the TypedefDecl.
|
|
|
|
VisitNamedDecl(TD);
|
|
|
|
TD->setUnderlyingType(Reader.GetType(Record[Idx + 1]));
|
|
|
|
TD->setTypeForDecl(Reader.GetType(Record[Idx]).getTypePtr());
|
|
|
|
Idx += 2;
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
2009-04-13 22:14:40 +04:00
|
|
|
void PCHDeclReader::VisitTagDecl(TagDecl *TD) {
|
|
|
|
VisitTypeDecl(TD);
|
|
|
|
TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
|
|
|
|
TD->setDefinition(Record[Idx++]);
|
|
|
|
TD->setTypedefForAnonDecl(
|
|
|
|
cast_or_null<TypedefDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitEnumDecl(EnumDecl *ED) {
|
|
|
|
VisitTagDecl(ED);
|
|
|
|
ED->setIntegerType(Reader.GetType(Record[Idx++]));
|
|
|
|
}
|
|
|
|
|
2009-04-14 01:20:57 +04:00
|
|
|
void PCHDeclReader::VisitRecordDecl(RecordDecl *RD) {
|
|
|
|
VisitTagDecl(RD);
|
|
|
|
RD->setHasFlexibleArrayMember(Record[Idx++]);
|
|
|
|
RD->setAnonymousStructOrUnion(Record[Idx++]);
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
void PCHDeclReader::VisitValueDecl(ValueDecl *VD) {
|
|
|
|
VisitNamedDecl(VD);
|
|
|
|
VD->setType(Reader.GetType(Record[Idx++]));
|
|
|
|
}
|
|
|
|
|
2009-04-13 22:14:40 +04:00
|
|
|
void PCHDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
|
|
|
|
VisitValueDecl(ECD);
|
2009-04-15 01:18:50 +04:00
|
|
|
if (Record[Idx++])
|
|
|
|
ECD->setInitExpr(Reader.ReadExpr());
|
2009-04-13 22:14:40 +04:00
|
|
|
ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
|
|
|
|
}
|
|
|
|
|
2009-04-14 02:18:37 +04:00
|
|
|
void PCHDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
|
|
|
|
VisitValueDecl(FD);
|
2009-04-17 04:04:06 +04:00
|
|
|
if (Record[Idx++])
|
|
|
|
FD->setBody(cast<CompoundStmt>(Reader.ReadStmt()));
|
2009-04-14 02:18:37 +04:00
|
|
|
FD->setPreviousDeclaration(
|
|
|
|
cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
FD->setStorageClass((FunctionDecl::StorageClass)Record[Idx++]);
|
|
|
|
FD->setInline(Record[Idx++]);
|
|
|
|
FD->setVirtual(Record[Idx++]);
|
|
|
|
FD->setPure(Record[Idx++]);
|
|
|
|
FD->setInheritedPrototype(Record[Idx++]);
|
|
|
|
FD->setHasPrototype(Record[Idx++]);
|
|
|
|
FD->setDeleted(Record[Idx++]);
|
|
|
|
FD->setTypeSpecStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
unsigned NumParams = Record[Idx++];
|
|
|
|
llvm::SmallVector<ParmVarDecl *, 16> Params;
|
|
|
|
Params.reserve(NumParams);
|
|
|
|
for (unsigned I = 0; I != NumParams; ++I)
|
|
|
|
Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
FD->setParams(Reader.getContext(), &Params[0], NumParams);
|
|
|
|
}
|
|
|
|
|
2009-04-14 01:20:57 +04:00
|
|
|
void PCHDeclReader::VisitFieldDecl(FieldDecl *FD) {
|
|
|
|
VisitValueDecl(FD);
|
|
|
|
FD->setMutable(Record[Idx++]);
|
2009-04-15 01:18:50 +04:00
|
|
|
if (Record[Idx++])
|
|
|
|
FD->setBitWidth(Reader.ReadExpr());
|
2009-04-14 01:20:57 +04:00
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
void PCHDeclReader::VisitVarDecl(VarDecl *VD) {
|
|
|
|
VisitValueDecl(VD);
|
|
|
|
VD->setStorageClass((VarDecl::StorageClass)Record[Idx++]);
|
|
|
|
VD->setThreadSpecified(Record[Idx++]);
|
|
|
|
VD->setCXXDirectInitializer(Record[Idx++]);
|
|
|
|
VD->setDeclaredInCondition(Record[Idx++]);
|
|
|
|
VD->setPreviousDeclaration(
|
|
|
|
cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
VD->setTypeSpecStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
2009-04-15 01:18:50 +04:00
|
|
|
if (Record[Idx++])
|
|
|
|
VD->setInit(Reader.ReadExpr());
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
2009-04-14 02:18:37 +04:00
|
|
|
void PCHDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
|
|
|
|
VisitVarDecl(PD);
|
|
|
|
PD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
|
2009-04-16 02:19:53 +04:00
|
|
|
// FIXME: default argument (C++ only)
|
2009-04-14 02:18:37 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitOriginalParmVarDecl(OriginalParmVarDecl *PD) {
|
|
|
|
VisitParmVarDecl(PD);
|
|
|
|
PD->setOriginalType(Reader.GetType(Record[Idx++]));
|
|
|
|
}
|
|
|
|
|
2009-04-14 02:49:25 +04:00
|
|
|
void PCHDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
|
|
|
|
VisitDecl(AD);
|
2009-04-15 22:43:11 +04:00
|
|
|
AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr()));
|
2009-04-14 02:49:25 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void PCHDeclReader::VisitBlockDecl(BlockDecl *BD) {
|
|
|
|
VisitDecl(BD);
|
|
|
|
unsigned NumParams = Record[Idx++];
|
|
|
|
llvm::SmallVector<ParmVarDecl *, 16> Params;
|
|
|
|
Params.reserve(NumParams);
|
|
|
|
for (unsigned I = 0; I != NumParams; ++I)
|
|
|
|
Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
BD->setParams(Reader.getContext(), &Params[0], NumParams);
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
std::pair<uint64_t, uint64_t>
|
|
|
|
PCHDeclReader::VisitDeclContext(DeclContext *DC) {
|
|
|
|
uint64_t LexicalOffset = Record[Idx++];
|
|
|
|
uint64_t VisibleOffset = 0;
|
|
|
|
if (DC->getPrimaryContext() == DC)
|
|
|
|
VisibleOffset = Record[Idx++];
|
|
|
|
return std::make_pair(LexicalOffset, VisibleOffset);
|
|
|
|
}
|
|
|
|
|
2009-04-15 01:18:50 +04:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Statement/expression deserialization
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
|
|
|
class VISIBILITY_HIDDEN PCHStmtReader
|
2009-04-15 03:32:43 +04:00
|
|
|
: public StmtVisitor<PCHStmtReader, unsigned> {
|
2009-04-15 01:18:50 +04:00
|
|
|
PCHReader &Reader;
|
|
|
|
const PCHReader::RecordData &Record;
|
|
|
|
unsigned &Idx;
|
2009-04-17 02:23:12 +04:00
|
|
|
llvm::SmallVectorImpl<Stmt *> &StmtStack;
|
2009-04-15 01:18:50 +04:00
|
|
|
|
|
|
|
public:
|
|
|
|
PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record,
|
2009-04-17 02:23:12 +04:00
|
|
|
unsigned &Idx, llvm::SmallVectorImpl<Stmt *> &StmtStack)
|
|
|
|
: Reader(Reader), Record(Record), Idx(Idx), StmtStack(StmtStack) { }
|
2009-04-15 03:32:43 +04:00
|
|
|
|
2009-04-17 04:04:06 +04:00
|
|
|
/// \brief The number of record fields required for the Stmt class
|
|
|
|
/// itself.
|
|
|
|
static const unsigned NumStmtFields = 0;
|
|
|
|
|
2009-04-15 20:35:07 +04:00
|
|
|
/// \brief The number of record fields required for the Expr class
|
|
|
|
/// itself.
|
2009-04-17 04:04:06 +04:00
|
|
|
static const unsigned NumExprFields = NumStmtFields + 3;
|
2009-04-15 20:35:07 +04:00
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
// Each of the Visit* functions reads in part of the expression
|
|
|
|
// from the given record and the current expression stack, then
|
|
|
|
// return the total number of operands that it read from the
|
|
|
|
// expression stack.
|
|
|
|
|
2009-04-17 04:04:06 +04:00
|
|
|
unsigned VisitStmt(Stmt *S);
|
|
|
|
unsigned VisitNullStmt(NullStmt *S);
|
|
|
|
unsigned VisitCompoundStmt(CompoundStmt *S);
|
|
|
|
unsigned VisitSwitchCase(SwitchCase *S);
|
|
|
|
unsigned VisitCaseStmt(CaseStmt *S);
|
|
|
|
unsigned VisitDefaultStmt(DefaultStmt *S);
|
|
|
|
unsigned VisitIfStmt(IfStmt *S);
|
|
|
|
unsigned VisitSwitchStmt(SwitchStmt *S);
|
2009-04-17 04:16:09 +04:00
|
|
|
unsigned VisitWhileStmt(WhileStmt *S);
|
2009-04-17 04:29:51 +04:00
|
|
|
unsigned VisitDoStmt(DoStmt *S);
|
|
|
|
unsigned VisitForStmt(ForStmt *S);
|
2009-04-17 04:16:09 +04:00
|
|
|
unsigned VisitContinueStmt(ContinueStmt *S);
|
2009-04-17 04:04:06 +04:00
|
|
|
unsigned VisitBreakStmt(BreakStmt *S);
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned VisitExpr(Expr *E);
|
|
|
|
unsigned VisitPredefinedExpr(PredefinedExpr *E);
|
|
|
|
unsigned VisitDeclRefExpr(DeclRefExpr *E);
|
|
|
|
unsigned VisitIntegerLiteral(IntegerLiteral *E);
|
|
|
|
unsigned VisitFloatingLiteral(FloatingLiteral *E);
|
2009-04-16 02:19:53 +04:00
|
|
|
unsigned VisitImaginaryLiteral(ImaginaryLiteral *E);
|
2009-04-15 20:35:07 +04:00
|
|
|
unsigned VisitStringLiteral(StringLiteral *E);
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned VisitCharacterLiteral(CharacterLiteral *E);
|
2009-04-15 03:59:37 +04:00
|
|
|
unsigned VisitParenExpr(ParenExpr *E);
|
2009-04-15 19:58:59 +04:00
|
|
|
unsigned VisitUnaryOperator(UnaryOperator *E);
|
|
|
|
unsigned VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
|
2009-04-16 02:19:53 +04:00
|
|
|
unsigned VisitArraySubscriptExpr(ArraySubscriptExpr *E);
|
2009-04-15 21:43:59 +04:00
|
|
|
unsigned VisitCallExpr(CallExpr *E);
|
|
|
|
unsigned VisitMemberExpr(MemberExpr *E);
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned VisitCastExpr(CastExpr *E);
|
2009-04-15 04:25:59 +04:00
|
|
|
unsigned VisitBinaryOperator(BinaryOperator *E);
|
2009-04-16 02:40:36 +04:00
|
|
|
unsigned VisitCompoundAssignOperator(CompoundAssignOperator *E);
|
|
|
|
unsigned VisitConditionalOperator(ConditionalOperator *E);
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned VisitImplicitCastExpr(ImplicitCastExpr *E);
|
2009-04-15 04:25:59 +04:00
|
|
|
unsigned VisitExplicitCastExpr(ExplicitCastExpr *E);
|
|
|
|
unsigned VisitCStyleCastExpr(CStyleCastExpr *E);
|
2009-04-16 06:33:48 +04:00
|
|
|
unsigned VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
|
2009-04-16 03:02:49 +04:00
|
|
|
unsigned VisitExtVectorElementExpr(ExtVectorElementExpr *E);
|
2009-04-16 04:55:48 +04:00
|
|
|
unsigned VisitInitListExpr(InitListExpr *E);
|
|
|
|
unsigned VisitDesignatedInitExpr(DesignatedInitExpr *E);
|
|
|
|
unsigned VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
|
2009-04-16 03:02:49 +04:00
|
|
|
unsigned VisitVAArgExpr(VAArgExpr *E);
|
2009-04-16 03:33:31 +04:00
|
|
|
unsigned VisitTypesCompatibleExpr(TypesCompatibleExpr *E);
|
|
|
|
unsigned VisitChooseExpr(ChooseExpr *E);
|
|
|
|
unsigned VisitGNUNullExpr(GNUNullExpr *E);
|
2009-04-16 04:01:45 +04:00
|
|
|
unsigned VisitShuffleVectorExpr(ShuffleVectorExpr *E);
|
|
|
|
unsigned VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
|
2009-04-15 01:18:50 +04:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-04-17 04:04:06 +04:00
|
|
|
unsigned PCHStmtReader::VisitStmt(Stmt *S) {
|
|
|
|
assert(Idx == NumStmtFields && "Incorrect statement field count");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitNullStmt(NullStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setSemiLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitCompoundStmt(CompoundStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
unsigned NumStmts = Record[Idx++];
|
|
|
|
S->setStmts(Reader.getContext(),
|
|
|
|
&StmtStack[StmtStack.size() - NumStmts], NumStmts);
|
|
|
|
S->setLBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
S->setRBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return NumStmts;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitSwitchCase(SwitchCase *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
Reader.RecordSwitchCaseID(S, Record[Idx++]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitCaseStmt(CaseStmt *S) {
|
|
|
|
VisitSwitchCase(S);
|
|
|
|
S->setLHS(cast<Expr>(StmtStack[StmtStack.size() - 3]));
|
|
|
|
S->setRHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
S->setSubStmt(StmtStack.back());
|
|
|
|
S->setCaseLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitDefaultStmt(DefaultStmt *S) {
|
|
|
|
VisitSwitchCase(S);
|
|
|
|
S->setSubStmt(StmtStack.back());
|
|
|
|
S->setDefaultLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitIfStmt(IfStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setCond(cast<Expr>(StmtStack[StmtStack.size() - 3]));
|
|
|
|
S->setThen(StmtStack[StmtStack.size() - 2]);
|
|
|
|
S->setElse(StmtStack[StmtStack.size() - 1]);
|
|
|
|
S->setIfLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitSwitchStmt(SwitchStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setCond(cast<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
S->setBody(StmtStack.back());
|
|
|
|
S->setSwitchLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
SwitchCase *PrevSC = 0;
|
|
|
|
for (unsigned N = Record.size(); Idx != N; ++Idx) {
|
|
|
|
SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
|
|
|
|
if (PrevSC)
|
|
|
|
PrevSC->setNextSwitchCase(SC);
|
|
|
|
else
|
|
|
|
S->setSwitchCaseList(SC);
|
|
|
|
PrevSC = SC;
|
|
|
|
}
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2009-04-17 04:16:09 +04:00
|
|
|
unsigned PCHStmtReader::VisitWhileStmt(WhileStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setCond(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
S->setBody(StmtStack.back());
|
|
|
|
S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2009-04-17 04:29:51 +04:00
|
|
|
unsigned PCHStmtReader::VisitDoStmt(DoStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setCond(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
S->setBody(StmtStack.back());
|
|
|
|
S->setDoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitForStmt(ForStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setInit(StmtStack[StmtStack.size() - 4]);
|
|
|
|
S->setCond(cast_or_null<Expr>(StmtStack[StmtStack.size() - 3]));
|
|
|
|
S->setInc(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
S->setBody(StmtStack.back());
|
|
|
|
S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
|
2009-04-17 04:16:09 +04:00
|
|
|
unsigned PCHStmtReader::VisitContinueStmt(ContinueStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setContinueLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-17 04:04:06 +04:00
|
|
|
unsigned PCHStmtReader::VisitBreakStmt(BreakStmt *S) {
|
|
|
|
VisitStmt(S);
|
|
|
|
S->setBreakLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitExpr(Expr *E) {
|
2009-04-17 04:04:06 +04:00
|
|
|
VisitStmt(E);
|
2009-04-15 01:18:50 +04:00
|
|
|
E->setType(Reader.GetType(Record[Idx++]));
|
|
|
|
E->setTypeDependent(Record[Idx++]);
|
|
|
|
E->setValueDependent(Record[Idx++]);
|
2009-04-15 20:35:07 +04:00
|
|
|
assert(Idx == NumExprFields && "Incorrect expression field count");
|
2009-04-15 03:32:43 +04:00
|
|
|
return 0;
|
2009-04-15 01:18:50 +04:00
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
|
2009-04-15 01:55:33 +04:00
|
|
|
VisitExpr(E);
|
|
|
|
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
|
2009-04-15 03:32:43 +04:00
|
|
|
return 0;
|
2009-04-15 01:55:33 +04:00
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
|
2009-04-15 01:18:50 +04:00
|
|
|
VisitExpr(E);
|
|
|
|
E->setDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
2009-04-15 03:32:43 +04:00
|
|
|
return 0;
|
2009-04-15 01:18:50 +04:00
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
|
2009-04-15 01:18:50 +04:00
|
|
|
VisitExpr(E);
|
|
|
|
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setValue(Reader.ReadAPInt(Record, Idx));
|
2009-04-15 03:32:43 +04:00
|
|
|
return 0;
|
2009-04-15 01:18:50 +04:00
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
|
2009-04-15 01:55:33 +04:00
|
|
|
VisitExpr(E);
|
|
|
|
E->setValue(Reader.ReadAPFloat(Record, Idx));
|
|
|
|
E->setExact(Record[Idx++]);
|
|
|
|
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
2009-04-15 03:32:43 +04:00
|
|
|
return 0;
|
2009-04-15 01:55:33 +04:00
|
|
|
}
|
|
|
|
|
2009-04-16 02:19:53 +04:00
|
|
|
unsigned PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setSubExpr(cast<Expr>(StmtStack.back()));
|
2009-04-16 02:19:53 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-15 20:35:07 +04:00
|
|
|
unsigned PCHStmtReader::VisitStringLiteral(StringLiteral *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
unsigned Len = Record[Idx++];
|
|
|
|
assert(Record[Idx] == E->getNumConcatenated() &&
|
|
|
|
"Wrong number of concatenated tokens!");
|
|
|
|
++Idx;
|
|
|
|
E->setWide(Record[Idx++]);
|
|
|
|
|
|
|
|
// Read string data
|
|
|
|
llvm::SmallVector<char, 16> Str(&Record[Idx], &Record[Idx] + Len);
|
|
|
|
E->setStrData(Reader.getContext(), &Str[0], Len);
|
|
|
|
Idx += Len;
|
|
|
|
|
|
|
|
// Read source locations
|
|
|
|
for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
|
|
|
|
E->setStrTokenLoc(I, SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
|
2009-04-15 01:18:50 +04:00
|
|
|
VisitExpr(E);
|
|
|
|
E->setValue(Record[Idx++]);
|
|
|
|
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setWide(Record[Idx++]);
|
2009-04-15 03:32:43 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-15 03:59:37 +04:00
|
|
|
unsigned PCHStmtReader::VisitParenExpr(ParenExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setLParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setSubExpr(cast<Expr>(StmtStack.back()));
|
2009-04-15 03:59:37 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-15 19:58:59 +04:00
|
|
|
unsigned PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setSubExpr(cast<Expr>(StmtStack.back()));
|
2009-04-15 19:58:59 +04:00
|
|
|
E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
|
|
|
|
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setSizeof(Record[Idx++]);
|
|
|
|
if (Record[Idx] == 0) {
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setArgument(cast<Expr>(StmtStack.back()));
|
2009-04-15 19:58:59 +04:00
|
|
|
++Idx;
|
|
|
|
} else {
|
|
|
|
E->setArgument(Reader.GetType(Record[Idx++]));
|
|
|
|
}
|
|
|
|
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return E->isArgumentType()? 0 : 1;
|
|
|
|
}
|
|
|
|
|
2009-04-16 02:19:53 +04:00
|
|
|
unsigned PCHStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setLHS(cast<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
E->setRHS(cast<Expr>(StmtStack[StmtStack.size() - 2]));
|
2009-04-16 02:19:53 +04:00
|
|
|
E->setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2009-04-15 21:43:59 +04:00
|
|
|
unsigned PCHStmtReader::VisitCallExpr(CallExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setNumArgs(Reader.getContext(), Record[Idx++]);
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setCallee(cast<Expr>(StmtStack[StmtStack.size() - E->getNumArgs() - 1]));
|
2009-04-15 21:43:59 +04:00
|
|
|
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setArg(I, cast<Expr>(StmtStack[StmtStack.size() - N + I]));
|
2009-04-15 21:43:59 +04:00
|
|
|
return E->getNumArgs() + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitMemberExpr(MemberExpr *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setBase(cast<Expr>(StmtStack.back()));
|
2009-04-15 21:43:59 +04:00
|
|
|
E->setMemberDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
E->setMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setArrow(Record[Idx++]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitCastExpr(CastExpr *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setSubExpr(cast<Expr>(StmtStack.back()));
|
2009-04-15 03:32:43 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-15 04:25:59 +04:00
|
|
|
unsigned PCHStmtReader::VisitBinaryOperator(BinaryOperator *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setLHS(cast<Expr>(StmtStack.end()[-2]));
|
|
|
|
E->setRHS(cast<Expr>(StmtStack.end()[-1]));
|
2009-04-15 04:25:59 +04:00
|
|
|
E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
|
|
|
|
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2009-04-16 02:40:36 +04:00
|
|
|
unsigned PCHStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
|
|
|
|
VisitBinaryOperator(E);
|
|
|
|
E->setComputationLHSType(Reader.GetType(Record[Idx++]));
|
|
|
|
E->setComputationResultType(Reader.GetType(Record[Idx++]));
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setCond(cast<Expr>(StmtStack[StmtStack.size() - 3]));
|
|
|
|
E->setLHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
E->setRHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 1]));
|
2009-04-16 02:40:36 +04:00
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned PCHStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
|
|
|
|
VisitCastExpr(E);
|
|
|
|
E->setLvalueCast(Record[Idx++]);
|
|
|
|
return 1;
|
2009-04-15 01:18:50 +04:00
|
|
|
}
|
|
|
|
|
2009-04-15 04:25:59 +04:00
|
|
|
unsigned PCHStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
|
|
|
|
VisitCastExpr(E);
|
|
|
|
E->setTypeAsWritten(Reader.GetType(Record[Idx++]));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
|
|
|
|
VisitExplicitCastExpr(E);
|
|
|
|
E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-16 06:33:48 +04:00
|
|
|
unsigned PCHStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setInitializer(cast<Expr>(StmtStack.back()));
|
2009-04-16 06:33:48 +04:00
|
|
|
E->setFileScope(Record[Idx++]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-16 03:02:49 +04:00
|
|
|
unsigned PCHStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setBase(cast<Expr>(StmtStack.back()));
|
2009-04-16 03:02:49 +04:00
|
|
|
E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
|
|
|
|
E->setAccessorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-16 04:55:48 +04:00
|
|
|
unsigned PCHStmtReader::VisitInitListExpr(InitListExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
unsigned NumInits = Record[Idx++];
|
|
|
|
E->reserveInits(NumInits);
|
|
|
|
for (unsigned I = 0; I != NumInits; ++I)
|
2009-04-17 02:23:12 +04:00
|
|
|
E->updateInit(I,
|
|
|
|
cast<Expr>(StmtStack[StmtStack.size() - NumInits - 1 + I]));
|
|
|
|
E->setSyntacticForm(cast_or_null<InitListExpr>(StmtStack.back()));
|
2009-04-16 04:55:48 +04:00
|
|
|
E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setInitializedFieldInUnion(
|
|
|
|
cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
E->sawArrayRangeDesignator(Record[Idx++]);
|
|
|
|
return NumInits + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
|
|
|
|
typedef DesignatedInitExpr::Designator Designator;
|
|
|
|
|
|
|
|
VisitExpr(E);
|
|
|
|
unsigned NumSubExprs = Record[Idx++];
|
|
|
|
assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
|
|
|
|
for (unsigned I = 0; I != NumSubExprs; ++I)
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setSubExpr(I, cast<Expr>(StmtStack[StmtStack.size() - NumSubExprs + I]));
|
2009-04-16 04:55:48 +04:00
|
|
|
E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setGNUSyntax(Record[Idx++]);
|
|
|
|
|
|
|
|
llvm::SmallVector<Designator, 4> Designators;
|
|
|
|
while (Idx < Record.size()) {
|
|
|
|
switch ((pch::DesignatorTypes)Record[Idx++]) {
|
|
|
|
case pch::DESIG_FIELD_DECL: {
|
|
|
|
FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
|
|
|
|
SourceLocation DotLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
SourceLocation FieldLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
|
|
|
|
FieldLoc));
|
|
|
|
Designators.back().setField(Field);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DESIG_FIELD_NAME: {
|
|
|
|
const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
|
|
|
|
SourceLocation DotLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
SourceLocation FieldLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
Designators.push_back(Designator(Name, DotLoc, FieldLoc));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DESIG_ARRAY: {
|
|
|
|
unsigned Index = Record[Idx++];
|
|
|
|
SourceLocation LBracketLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
SourceLocation RBracketLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DESIG_ARRAY_RANGE: {
|
|
|
|
unsigned Index = Record[Idx++];
|
|
|
|
SourceLocation LBracketLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
SourceLocation EllipsisLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
SourceLocation RBracketLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[Idx++]);
|
|
|
|
Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
|
|
|
|
RBracketLoc));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
E->setDesignators(&Designators[0], Designators.size());
|
|
|
|
|
|
|
|
return NumSubExprs;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-16 03:02:49 +04:00
|
|
|
unsigned PCHStmtReader::VisitVAArgExpr(VAArgExpr *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setSubExpr(cast<Expr>(StmtStack.back()));
|
2009-04-16 03:02:49 +04:00
|
|
|
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-04-16 03:33:31 +04:00
|
|
|
unsigned PCHStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setArgType1(Reader.GetType(Record[Idx++]));
|
|
|
|
E->setArgType2(Reader.GetType(Record[Idx++]));
|
|
|
|
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitChooseExpr(ChooseExpr *E) {
|
|
|
|
VisitExpr(E);
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setCond(cast<Expr>(StmtStack[StmtStack.size() - 3]));
|
|
|
|
E->setLHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
|
|
|
|
E->setRHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 1]));
|
2009-04-16 03:33:31 +04:00
|
|
|
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setTokenLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return 0;
|
|
|
|
}
|
2009-04-16 03:02:49 +04:00
|
|
|
|
2009-04-16 04:01:45 +04:00
|
|
|
unsigned PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
unsigned NumExprs = Record[Idx++];
|
2009-04-17 02:23:12 +04:00
|
|
|
E->setExprs((Expr **)&StmtStack[StmtStack.size() - NumExprs], NumExprs);
|
2009-04-16 04:01:45 +04:00
|
|
|
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
return NumExprs;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PCHStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
|
|
|
|
VisitExpr(E);
|
|
|
|
E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
|
|
|
|
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
|
|
|
|
E->setByRef(Record[Idx++]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
// FIXME: use the diagnostics machinery
|
|
|
|
static bool Error(const char *Str) {
|
|
|
|
std::fprintf(stderr, "%s\n", Str);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-04-11 03:10:45 +04:00
|
|
|
/// \brief Check the contents of the predefines buffer against the
|
|
|
|
/// contents of the predefines buffer used to build the PCH file.
|
|
|
|
///
|
|
|
|
/// The contents of the two predefines buffers should be the same. If
|
|
|
|
/// not, then some command-line option changed the preprocessor state
|
|
|
|
/// and we must reject the PCH file.
|
|
|
|
///
|
|
|
|
/// \param PCHPredef The start of the predefines buffer in the PCH
|
|
|
|
/// file.
|
|
|
|
///
|
|
|
|
/// \param PCHPredefLen The length of the predefines buffer in the PCH
|
|
|
|
/// file.
|
|
|
|
///
|
|
|
|
/// \param PCHBufferID The FileID for the PCH predefines buffer.
|
|
|
|
///
|
|
|
|
/// \returns true if there was a mismatch (in which case the PCH file
|
|
|
|
/// should be ignored), or false otherwise.
|
|
|
|
bool PCHReader::CheckPredefinesBuffer(const char *PCHPredef,
|
|
|
|
unsigned PCHPredefLen,
|
|
|
|
FileID PCHBufferID) {
|
|
|
|
const char *Predef = PP.getPredefines().c_str();
|
|
|
|
unsigned PredefLen = PP.getPredefines().size();
|
|
|
|
|
|
|
|
// If the two predefines buffers compare equal, we're done!.
|
|
|
|
if (PredefLen == PCHPredefLen &&
|
|
|
|
strncmp(Predef, PCHPredef, PCHPredefLen) == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// The predefines buffers are different. Produce a reasonable
|
|
|
|
// diagnostic showing where they are different.
|
|
|
|
|
|
|
|
// The source locations (potentially in the two different predefines
|
|
|
|
// buffers)
|
|
|
|
SourceLocation Loc1, Loc2;
|
|
|
|
SourceManager &SourceMgr = PP.getSourceManager();
|
|
|
|
|
|
|
|
// Create a source buffer for our predefines string, so
|
|
|
|
// that we can build a diagnostic that points into that
|
|
|
|
// source buffer.
|
|
|
|
FileID BufferID;
|
|
|
|
if (Predef && Predef[0]) {
|
|
|
|
llvm::MemoryBuffer *Buffer
|
|
|
|
= llvm::MemoryBuffer::getMemBuffer(Predef, Predef + PredefLen,
|
|
|
|
"<built-in>");
|
|
|
|
BufferID = SourceMgr.createFileIDForMemBuffer(Buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned MinLen = std::min(PredefLen, PCHPredefLen);
|
|
|
|
std::pair<const char *, const char *> Locations
|
|
|
|
= std::mismatch(Predef, Predef + MinLen, PCHPredef);
|
|
|
|
|
|
|
|
if (Locations.first != Predef + MinLen) {
|
|
|
|
// We found the location in the two buffers where there is a
|
|
|
|
// difference. Form source locations to point there (in both
|
|
|
|
// buffers).
|
|
|
|
unsigned Offset = Locations.first - Predef;
|
|
|
|
Loc1 = SourceMgr.getLocForStartOfFile(BufferID)
|
|
|
|
.getFileLocWithOffset(Offset);
|
|
|
|
Loc2 = SourceMgr.getLocForStartOfFile(PCHBufferID)
|
|
|
|
.getFileLocWithOffset(Offset);
|
|
|
|
} else if (PredefLen > PCHPredefLen) {
|
|
|
|
Loc1 = SourceMgr.getLocForStartOfFile(BufferID)
|
|
|
|
.getFileLocWithOffset(MinLen);
|
|
|
|
} else {
|
|
|
|
Loc1 = SourceMgr.getLocForStartOfFile(PCHBufferID)
|
|
|
|
.getFileLocWithOffset(MinLen);
|
|
|
|
}
|
|
|
|
|
|
|
|
Diag(Loc1, diag::warn_pch_preprocessor);
|
|
|
|
if (Loc2.isValid())
|
|
|
|
Diag(Loc2, diag::note_predef_in_pch);
|
|
|
|
Diag(diag::note_ignoring_pch) << FileName;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-04-13 20:31:14 +04:00
|
|
|
/// \brief Read the line table in the source manager block.
|
|
|
|
/// \returns true if ther was an error.
|
|
|
|
static bool ParseLineTable(SourceManager &SourceMgr,
|
|
|
|
llvm::SmallVectorImpl<uint64_t> &Record) {
|
|
|
|
unsigned Idx = 0;
|
|
|
|
LineTableInfo &LineTable = SourceMgr.getLineTable();
|
|
|
|
|
|
|
|
// Parse the file names
|
2009-04-13 21:12:42 +04:00
|
|
|
std::map<int, int> FileIDs;
|
|
|
|
for (int I = 0, N = Record[Idx++]; I != N; ++I) {
|
2009-04-13 20:31:14 +04:00
|
|
|
// Extract the file name
|
|
|
|
unsigned FilenameLen = Record[Idx++];
|
|
|
|
std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
|
|
|
|
Idx += FilenameLen;
|
2009-04-13 21:12:42 +04:00
|
|
|
FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(),
|
|
|
|
Filename.size());
|
2009-04-13 20:31:14 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Parse the line entries
|
|
|
|
std::vector<LineEntry> Entries;
|
|
|
|
while (Idx < Record.size()) {
|
2009-04-13 21:12:42 +04:00
|
|
|
int FID = FileIDs[Record[Idx++]];
|
2009-04-13 20:31:14 +04:00
|
|
|
|
|
|
|
// Extract the line entries
|
|
|
|
unsigned NumEntries = Record[Idx++];
|
|
|
|
Entries.clear();
|
|
|
|
Entries.reserve(NumEntries);
|
|
|
|
for (unsigned I = 0; I != NumEntries; ++I) {
|
|
|
|
unsigned FileOffset = Record[Idx++];
|
|
|
|
unsigned LineNo = Record[Idx++];
|
|
|
|
int FilenameID = Record[Idx++];
|
|
|
|
SrcMgr::CharacteristicKind FileKind
|
|
|
|
= (SrcMgr::CharacteristicKind)Record[Idx++];
|
|
|
|
unsigned IncludeOffset = Record[Idx++];
|
|
|
|
Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
|
|
|
|
FileKind, IncludeOffset));
|
|
|
|
}
|
|
|
|
LineTable.AddEntry(FID, Entries);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-04-10 07:52:48 +04:00
|
|
|
/// \brief Read the source manager block
|
2009-04-11 03:10:45 +04:00
|
|
|
PCHReader::PCHReadResult PCHReader::ReadSourceManagerBlock() {
|
2009-04-10 07:52:48 +04:00
|
|
|
using namespace SrcMgr;
|
2009-04-11 03:10:45 +04:00
|
|
|
if (Stream.EnterSubBlock(pch::SOURCE_MANAGER_BLOCK_ID)) {
|
|
|
|
Error("Malformed source manager block record");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 07:52:48 +04:00
|
|
|
|
|
|
|
SourceManager &SourceMgr = Context.getSourceManager();
|
|
|
|
RecordData Record;
|
|
|
|
while (true) {
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
if (Code == llvm::bitc::END_BLOCK) {
|
2009-04-11 03:10:45 +04:00
|
|
|
if (Stream.ReadBlockEnd()) {
|
|
|
|
Error("Error at end of Source Manager block");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Success;
|
2009-04-10 07:52:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
|
|
|
|
// No known subblocks, always skip them.
|
|
|
|
Stream.ReadSubBlockID();
|
2009-04-11 03:10:45 +04:00
|
|
|
if (Stream.SkipBlock()) {
|
|
|
|
Error("Malformed block record");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 07:52:48 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Code == llvm::bitc::DEFINE_ABBREV) {
|
|
|
|
Stream.ReadAbbrevRecord();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read a record.
|
|
|
|
const char *BlobStart;
|
|
|
|
unsigned BlobLen;
|
|
|
|
Record.clear();
|
|
|
|
switch (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
|
|
|
|
default: // Default behavior: ignore.
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::SM_SLOC_FILE_ENTRY: {
|
|
|
|
// FIXME: We would really like to delay the creation of this
|
|
|
|
// FileEntry until it is actually required, e.g., when producing
|
|
|
|
// a diagnostic with a source location in this file.
|
|
|
|
const FileEntry *File
|
|
|
|
= PP.getFileManager().getFile(BlobStart, BlobStart + BlobLen);
|
|
|
|
// FIXME: Error recovery if file cannot be found.
|
2009-04-13 20:31:14 +04:00
|
|
|
FileID ID = SourceMgr.createFileID(File,
|
|
|
|
SourceLocation::getFromRawEncoding(Record[1]),
|
|
|
|
(CharacteristicKind)Record[2]);
|
|
|
|
if (Record[3])
|
|
|
|
const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(ID).getFile())
|
|
|
|
.setHasLineDirectives();
|
2009-04-10 07:52:48 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::SM_SLOC_BUFFER_ENTRY: {
|
|
|
|
const char *Name = BlobStart;
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
Record.clear();
|
|
|
|
unsigned RecCode = Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen);
|
|
|
|
assert(RecCode == pch::SM_SLOC_BUFFER_BLOB && "Ill-formed PCH file");
|
2009-04-15 22:43:11 +04:00
|
|
|
(void)RecCode;
|
2009-04-11 03:10:45 +04:00
|
|
|
llvm::MemoryBuffer *Buffer
|
|
|
|
= llvm::MemoryBuffer::getMemBuffer(BlobStart,
|
|
|
|
BlobStart + BlobLen - 1,
|
|
|
|
Name);
|
|
|
|
FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer);
|
|
|
|
|
|
|
|
if (strcmp(Name, "<built-in>") == 0
|
|
|
|
&& CheckPredefinesBuffer(BlobStart, BlobLen - 1, BufferID))
|
|
|
|
return IgnorePCH;
|
2009-04-10 07:52:48 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::SM_SLOC_INSTANTIATION_ENTRY: {
|
|
|
|
SourceLocation SpellingLoc
|
|
|
|
= SourceLocation::getFromRawEncoding(Record[1]);
|
|
|
|
SourceMgr.createInstantiationLoc(
|
|
|
|
SpellingLoc,
|
|
|
|
SourceLocation::getFromRawEncoding(Record[2]),
|
|
|
|
SourceLocation::getFromRawEncoding(Record[3]),
|
2009-04-15 22:05:10 +04:00
|
|
|
Record[4]);
|
2009-04-10 07:52:48 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-15 03:22:57 +04:00
|
|
|
case pch::SM_LINE_TABLE:
|
2009-04-13 20:31:14 +04:00
|
|
|
if (ParseLineTable(SourceMgr, Record))
|
|
|
|
return Failure;
|
2009-04-15 03:22:57 +04:00
|
|
|
break;
|
2009-04-10 07:52:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-11 01:41:48 +04:00
|
|
|
bool PCHReader::ReadPreprocessorBlock() {
|
|
|
|
if (Stream.EnterSubBlock(pch::PREPROCESSOR_BLOCK_ID))
|
|
|
|
return Error("Malformed preprocessor block record");
|
|
|
|
|
|
|
|
RecordData Record;
|
|
|
|
llvm::SmallVector<IdentifierInfo*, 16> MacroArgs;
|
|
|
|
MacroInfo *LastMacro = 0;
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
switch (Code) {
|
|
|
|
case llvm::bitc::END_BLOCK:
|
|
|
|
if (Stream.ReadBlockEnd())
|
|
|
|
return Error("Error at end of preprocessor block");
|
|
|
|
return false;
|
|
|
|
|
|
|
|
case llvm::bitc::ENTER_SUBBLOCK:
|
|
|
|
// No known subblocks, always skip them.
|
|
|
|
Stream.ReadSubBlockID();
|
|
|
|
if (Stream.SkipBlock())
|
|
|
|
return Error("Malformed block record");
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case llvm::bitc::DEFINE_ABBREV:
|
|
|
|
Stream.ReadAbbrevRecord();
|
|
|
|
continue;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read a record.
|
|
|
|
Record.clear();
|
|
|
|
pch::PreprocessorRecordTypes RecType =
|
|
|
|
(pch::PreprocessorRecordTypes)Stream.ReadRecord(Code, Record);
|
|
|
|
switch (RecType) {
|
|
|
|
default: // Default behavior: ignore unknown records.
|
|
|
|
break;
|
2009-04-13 05:29:17 +04:00
|
|
|
case pch::PP_COUNTER_VALUE:
|
|
|
|
if (!Record.empty())
|
|
|
|
PP.setCounterValue(Record[0]);
|
|
|
|
break;
|
|
|
|
|
2009-04-11 01:41:48 +04:00
|
|
|
case pch::PP_MACRO_OBJECT_LIKE:
|
|
|
|
case pch::PP_MACRO_FUNCTION_LIKE: {
|
2009-04-12 01:15:38 +04:00
|
|
|
IdentifierInfo *II = DecodeIdentifierInfo(Record[0]);
|
|
|
|
if (II == 0)
|
|
|
|
return Error("Macro must have a name");
|
2009-04-11 01:41:48 +04:00
|
|
|
SourceLocation Loc = SourceLocation::getFromRawEncoding(Record[1]);
|
|
|
|
bool isUsed = Record[2];
|
|
|
|
|
|
|
|
MacroInfo *MI = PP.AllocateMacroInfo(Loc);
|
|
|
|
MI->setIsUsed(isUsed);
|
|
|
|
|
|
|
|
if (RecType == pch::PP_MACRO_FUNCTION_LIKE) {
|
|
|
|
// Decode function-like macro info.
|
|
|
|
bool isC99VarArgs = Record[3];
|
|
|
|
bool isGNUVarArgs = Record[4];
|
|
|
|
MacroArgs.clear();
|
|
|
|
unsigned NumArgs = Record[5];
|
|
|
|
for (unsigned i = 0; i != NumArgs; ++i)
|
2009-04-12 01:15:38 +04:00
|
|
|
MacroArgs.push_back(DecodeIdentifierInfo(Record[6+i]));
|
2009-04-11 01:41:48 +04:00
|
|
|
|
|
|
|
// Install function-like macro info.
|
|
|
|
MI->setIsFunctionLike();
|
|
|
|
if (isC99VarArgs) MI->setIsC99Varargs();
|
|
|
|
if (isGNUVarArgs) MI->setIsGNUVarargs();
|
|
|
|
MI->setArgumentList(&MacroArgs[0], MacroArgs.size(),
|
|
|
|
PP.getPreprocessorAllocator());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, install the macro.
|
|
|
|
PP.setMacroInfo(II, MI);
|
|
|
|
|
|
|
|
// Remember that we saw this macro last so that we add the tokens that
|
|
|
|
// form its body to it.
|
|
|
|
LastMacro = MI;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::PP_TOKEN: {
|
|
|
|
// If we see a TOKEN before a PP_MACRO_*, then the file is eroneous, just
|
|
|
|
// pretend we didn't see this.
|
|
|
|
if (LastMacro == 0) break;
|
|
|
|
|
|
|
|
Token Tok;
|
|
|
|
Tok.startToken();
|
|
|
|
Tok.setLocation(SourceLocation::getFromRawEncoding(Record[0]));
|
|
|
|
Tok.setLength(Record[1]);
|
2009-04-12 01:15:38 +04:00
|
|
|
if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2]))
|
|
|
|
Tok.setIdentifierInfo(II);
|
2009-04-11 01:41:48 +04:00
|
|
|
Tok.setKind((tok::TokenKind)Record[3]);
|
|
|
|
Tok.setFlag((Token::TokenFlags)Record[4]);
|
|
|
|
LastMacro->AddTokenToBody(Tok);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-11 00:39:37 +04:00
|
|
|
PCHReader::PCHReadResult PCHReader::ReadPCHBlock() {
|
|
|
|
if (Stream.EnterSubBlock(pch::PCH_BLOCK_ID)) {
|
|
|
|
Error("Malformed block record");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
|
2009-04-12 01:15:38 +04:00
|
|
|
uint64_t PreprocessorBlockBit = 0;
|
|
|
|
|
2009-04-10 21:25:41 +04:00
|
|
|
// Read all of the records and blocks for the PCH file.
|
2009-04-10 02:27:44 +04:00
|
|
|
RecordData Record;
|
2009-04-10 21:25:41 +04:00
|
|
|
while (!Stream.AtEndOfStream()) {
|
2009-04-10 02:27:44 +04:00
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
if (Code == llvm::bitc::END_BLOCK) {
|
2009-04-12 01:15:38 +04:00
|
|
|
// If we saw the preprocessor block, read it now.
|
|
|
|
if (PreprocessorBlockBit) {
|
|
|
|
uint64_t SavedPos = Stream.GetCurrentBitNo();
|
|
|
|
Stream.JumpToBit(PreprocessorBlockBit);
|
|
|
|
if (ReadPreprocessorBlock()) {
|
|
|
|
Error("Malformed preprocessor block");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
Stream.JumpToBit(SavedPos);
|
|
|
|
}
|
|
|
|
|
2009-04-11 00:39:37 +04:00
|
|
|
if (Stream.ReadBlockEnd()) {
|
|
|
|
Error("Error at end of module block");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-12 01:15:38 +04:00
|
|
|
|
2009-04-11 00:39:37 +04:00
|
|
|
return Success;
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
2009-04-10 21:25:41 +04:00
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
|
2009-04-10 21:25:41 +04:00
|
|
|
switch (Stream.ReadSubBlockID()) {
|
|
|
|
case pch::DECLS_BLOCK_ID: // Skip decls block (lazily loaded)
|
|
|
|
case pch::TYPES_BLOCK_ID: // Skip types block (lazily loaded)
|
|
|
|
default: // Skip unknown content.
|
2009-04-11 00:39:37 +04:00
|
|
|
if (Stream.SkipBlock()) {
|
|
|
|
Error("Malformed block record");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 21:25:41 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-12 01:15:38 +04:00
|
|
|
case pch::PREPROCESSOR_BLOCK_ID:
|
|
|
|
// Skip the preprocessor block for now, but remember where it is. We
|
|
|
|
// want to read it in after the identifier table.
|
|
|
|
if (PreprocessorBlockBit) {
|
|
|
|
Error("Multiple preprocessor blocks found.");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
PreprocessorBlockBit = Stream.GetCurrentBitNo();
|
|
|
|
if (Stream.SkipBlock()) {
|
|
|
|
Error("Malformed block record");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2009-04-10 21:25:41 +04:00
|
|
|
case pch::SOURCE_MANAGER_BLOCK_ID:
|
2009-04-11 03:10:45 +04:00
|
|
|
switch (ReadSourceManagerBlock()) {
|
|
|
|
case Success:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Failure:
|
2009-04-11 00:39:37 +04:00
|
|
|
Error("Malformed source manager block");
|
|
|
|
return Failure;
|
2009-04-11 03:10:45 +04:00
|
|
|
|
|
|
|
case IgnorePCH:
|
|
|
|
return IgnorePCH;
|
2009-04-11 00:39:37 +04:00
|
|
|
}
|
2009-04-10 21:25:41 +04:00
|
|
|
break;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
continue;
|
|
|
|
}
|
2009-04-10 21:25:41 +04:00
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
if (Code == llvm::bitc::DEFINE_ABBREV) {
|
|
|
|
Stream.ReadAbbrevRecord();
|
|
|
|
continue;
|
|
|
|
}
|
2009-04-10 21:25:41 +04:00
|
|
|
|
|
|
|
// Read and process a record.
|
2009-04-10 02:27:44 +04:00
|
|
|
Record.clear();
|
2009-04-11 01:16:55 +04:00
|
|
|
const char *BlobStart = 0;
|
|
|
|
unsigned BlobLen = 0;
|
|
|
|
switch ((pch::PCHRecordTypes)Stream.ReadRecord(Code, Record,
|
|
|
|
&BlobStart, &BlobLen)) {
|
2009-04-10 02:27:44 +04:00
|
|
|
default: // Default behavior: ignore.
|
|
|
|
break;
|
2009-04-10 21:25:41 +04:00
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
case pch::TYPE_OFFSET:
|
2009-04-11 00:39:37 +04:00
|
|
|
if (!TypeOffsets.empty()) {
|
|
|
|
Error("Duplicate TYPE_OFFSET record in PCH file");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
TypeOffsets.swap(Record);
|
|
|
|
TypeAlreadyLoaded.resize(TypeOffsets.size(), false);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::DECL_OFFSET:
|
2009-04-11 00:39:37 +04:00
|
|
|
if (!DeclOffsets.empty()) {
|
|
|
|
Error("Duplicate DECL_OFFSET record in PCH file");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
DeclOffsets.swap(Record);
|
|
|
|
DeclAlreadyLoaded.resize(DeclOffsets.size(), false);
|
|
|
|
break;
|
2009-04-11 00:39:37 +04:00
|
|
|
|
|
|
|
case pch::LANGUAGE_OPTIONS:
|
|
|
|
if (ParseLanguageOptions(Record))
|
|
|
|
return IgnorePCH;
|
|
|
|
break;
|
2009-04-11 01:16:55 +04:00
|
|
|
|
2009-04-11 04:14:32 +04:00
|
|
|
case pch::TARGET_TRIPLE: {
|
2009-04-11 01:16:55 +04:00
|
|
|
std::string TargetTriple(BlobStart, BlobLen);
|
|
|
|
if (TargetTriple != Context.Target.getTargetTriple()) {
|
|
|
|
Diag(diag::warn_pch_target_triple)
|
|
|
|
<< TargetTriple << Context.Target.getTargetTriple();
|
|
|
|
Diag(diag::note_ignoring_pch) << FileName;
|
|
|
|
return IgnorePCH;
|
|
|
|
}
|
|
|
|
break;
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
2009-04-11 04:14:32 +04:00
|
|
|
|
|
|
|
case pch::IDENTIFIER_TABLE:
|
|
|
|
IdentifierTable = BlobStart;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::IDENTIFIER_OFFSET:
|
|
|
|
if (!IdentifierData.empty()) {
|
|
|
|
Error("Duplicate IDENTIFIER_OFFSET record in PCH file");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
IdentifierData.swap(Record);
|
|
|
|
#ifndef NDEBUG
|
|
|
|
for (unsigned I = 0, N = IdentifierData.size(); I != N; ++I) {
|
|
|
|
if ((IdentifierData[I] & 0x01) == 0) {
|
|
|
|
Error("Malformed identifier table in the precompiled header");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
break;
|
2009-04-14 04:24:19 +04:00
|
|
|
|
|
|
|
case pch::EXTERNAL_DEFINITIONS:
|
|
|
|
if (!ExternalDefinitions.empty()) {
|
|
|
|
Error("Duplicate EXTERNAL_DEFINITIONS record in PCH file");
|
|
|
|
return Failure;
|
|
|
|
}
|
|
|
|
ExternalDefinitions.swap(Record);
|
|
|
|
break;
|
2009-04-11 04:14:32 +04:00
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
2009-04-11 00:39:37 +04:00
|
|
|
Error("Premature end of bitstream");
|
|
|
|
return Failure;
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
2009-04-11 03:10:45 +04:00
|
|
|
PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) {
|
2009-04-11 00:39:37 +04:00
|
|
|
// Set the PCH file name.
|
|
|
|
this->FileName = FileName;
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
// Open the PCH file.
|
|
|
|
std::string ErrStr;
|
|
|
|
Buffer.reset(llvm::MemoryBuffer::getFile(FileName.c_str(), &ErrStr));
|
2009-04-11 03:10:45 +04:00
|
|
|
if (!Buffer) {
|
|
|
|
Error(ErrStr.c_str());
|
|
|
|
return IgnorePCH;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
|
|
|
|
// Initialize the stream
|
|
|
|
Stream.init((const unsigned char *)Buffer->getBufferStart(),
|
|
|
|
(const unsigned char *)Buffer->getBufferEnd());
|
|
|
|
|
|
|
|
// Sniff for the signature.
|
|
|
|
if (Stream.Read(8) != 'C' ||
|
|
|
|
Stream.Read(8) != 'P' ||
|
|
|
|
Stream.Read(8) != 'C' ||
|
2009-04-11 03:10:45 +04:00
|
|
|
Stream.Read(8) != 'H') {
|
|
|
|
Error("Not a PCH file");
|
|
|
|
return IgnorePCH;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
|
|
|
|
// We expect a number of well-defined blocks, though we don't necessarily
|
|
|
|
// need to understand them all.
|
|
|
|
while (!Stream.AtEndOfStream()) {
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
|
2009-04-11 03:10:45 +04:00
|
|
|
if (Code != llvm::bitc::ENTER_SUBBLOCK) {
|
|
|
|
Error("Invalid record at top-level");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
|
|
|
|
unsigned BlockID = Stream.ReadSubBlockID();
|
|
|
|
|
|
|
|
// We only know the PCH subblock ID.
|
|
|
|
switch (BlockID) {
|
|
|
|
case llvm::bitc::BLOCKINFO_BLOCK_ID:
|
2009-04-11 03:10:45 +04:00
|
|
|
if (Stream.ReadBlockInfoBlock()) {
|
|
|
|
Error("Malformed BlockInfoBlock");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
break;
|
|
|
|
case pch::PCH_BLOCK_ID:
|
2009-04-11 00:39:37 +04:00
|
|
|
switch (ReadPCHBlock()) {
|
|
|
|
case Success:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Failure:
|
2009-04-11 03:10:45 +04:00
|
|
|
return Failure;
|
2009-04-11 00:39:37 +04:00
|
|
|
|
|
|
|
case IgnorePCH:
|
2009-04-11 01:16:55 +04:00
|
|
|
// FIXME: We could consider reading through to the end of this
|
|
|
|
// PCH block, skipping subblocks, to see if there are other
|
|
|
|
// PCH blocks elsewhere.
|
2009-04-11 03:10:45 +04:00
|
|
|
return IgnorePCH;
|
2009-04-11 00:39:37 +04:00
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
break;
|
|
|
|
default:
|
2009-04-11 03:10:45 +04:00
|
|
|
if (Stream.SkipBlock()) {
|
|
|
|
Error("Malformed block record");
|
|
|
|
return Failure;
|
|
|
|
}
|
2009-04-10 02:27:44 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Load the translation unit declaration
|
|
|
|
ReadDeclRecord(DeclOffsets[0], 0);
|
|
|
|
|
2009-04-11 03:10:45 +04:00
|
|
|
return Success;
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
2009-04-15 01:18:50 +04:00
|
|
|
namespace {
|
|
|
|
/// \brief Helper class that saves the current stream position and
|
|
|
|
/// then restores it when destroyed.
|
|
|
|
struct VISIBILITY_HIDDEN SavedStreamPosition {
|
|
|
|
explicit SavedStreamPosition(llvm::BitstreamReader &Stream)
|
2009-04-15 08:54:29 +04:00
|
|
|
: Stream(Stream), Offset(Stream.GetCurrentBitNo()) { }
|
2009-04-15 01:18:50 +04:00
|
|
|
|
|
|
|
~SavedStreamPosition() {
|
2009-04-15 08:54:29 +04:00
|
|
|
Stream.JumpToBit(Offset);
|
2009-04-15 01:18:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
llvm::BitstreamReader &Stream;
|
|
|
|
uint64_t Offset;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-04-11 00:39:37 +04:00
|
|
|
/// \brief Parse the record that corresponds to a LangOptions data
|
|
|
|
/// structure.
|
|
|
|
///
|
|
|
|
/// This routine compares the language options used to generate the
|
|
|
|
/// PCH file against the language options set for the current
|
|
|
|
/// compilation. For each option, we classify differences between the
|
|
|
|
/// two compiler states as either "benign" or "important". Benign
|
|
|
|
/// differences don't matter, and we accept them without complaint
|
|
|
|
/// (and without modifying the language options). Differences between
|
|
|
|
/// the states for important options cause the PCH file to be
|
|
|
|
/// unusable, so we emit a warning and return true to indicate that
|
|
|
|
/// there was an error.
|
|
|
|
///
|
|
|
|
/// \returns true if the PCH file is unacceptable, false otherwise.
|
|
|
|
bool PCHReader::ParseLanguageOptions(
|
|
|
|
const llvm::SmallVectorImpl<uint64_t> &Record) {
|
|
|
|
const LangOptions &LangOpts = Context.getLangOptions();
|
|
|
|
#define PARSE_LANGOPT_BENIGN(Option) ++Idx
|
|
|
|
#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \
|
|
|
|
if (Record[Idx] != LangOpts.Option) { \
|
|
|
|
Diag(DiagID) << (unsigned)Record[Idx] << LangOpts.Option; \
|
|
|
|
Diag(diag::note_ignoring_pch) << FileName; \
|
|
|
|
return true; \
|
|
|
|
} \
|
|
|
|
++Idx
|
|
|
|
|
|
|
|
unsigned Idx = 0;
|
|
|
|
PARSE_LANGOPT_BENIGN(Trigraphs);
|
|
|
|
PARSE_LANGOPT_BENIGN(BCPLComment);
|
|
|
|
PARSE_LANGOPT_BENIGN(DollarIdents);
|
|
|
|
PARSE_LANGOPT_BENIGN(AsmPreprocessor);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions);
|
|
|
|
PARSE_LANGOPT_BENIGN(ImplicitInt);
|
|
|
|
PARSE_LANGOPT_BENIGN(Digraphs);
|
|
|
|
PARSE_LANGOPT_BENIGN(HexFloats);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(NoExtensions, diag::warn_pch_extensions);
|
|
|
|
PARSE_LANGOPT_BENIGN(CXXOperatorName);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi);
|
|
|
|
PARSE_LANGOPT_BENIGN(PascalStrings);
|
|
|
|
PARSE_LANGOPT_BENIGN(Boolean);
|
|
|
|
PARSE_LANGOPT_BENIGN(WritableStrings);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(LaxVectorConversions,
|
|
|
|
diag::warn_pch_lax_vector_conversions);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics,
|
|
|
|
diag::warn_pch_thread_safe_statics);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks);
|
|
|
|
PARSE_LANGOPT_BENIGN(EmitAllDecls);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(OverflowChecking, diag::warn_pch_overflow_checking);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(HeinousExtensions,
|
|
|
|
diag::warn_pch_heinous_extensions);
|
|
|
|
// FIXME: Most of the options below are benign if the macro wasn't
|
|
|
|
// used. Unfortunately, this means that a PCH compiled without
|
|
|
|
// optimization can't be used with optimization turned on, even
|
|
|
|
// though the only thing that changes is whether __OPTIMIZE__ was
|
|
|
|
// defined... but if __OPTIMIZE__ never showed up in the header, it
|
|
|
|
// doesn't matter. We could consider making this some special kind
|
|
|
|
// of check.
|
|
|
|
PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline);
|
|
|
|
PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline);
|
|
|
|
if ((LangOpts.getGCMode() != 0) != (Record[Idx] != 0)) {
|
|
|
|
Diag(diag::warn_pch_gc_mode)
|
|
|
|
<< (unsigned)Record[Idx] << LangOpts.getGCMode();
|
|
|
|
Diag(diag::note_ignoring_pch) << FileName;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
++Idx;
|
|
|
|
PARSE_LANGOPT_BENIGN(getVisibilityMode());
|
|
|
|
PARSE_LANGOPT_BENIGN(InstantiationDepth);
|
|
|
|
#undef PARSE_LANGOPT_IRRELEVANT
|
|
|
|
#undef PARSE_LANGOPT_BENIGN
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
/// \brief Read and return the type at the given offset.
|
|
|
|
///
|
|
|
|
/// This routine actually reads the record corresponding to the type
|
|
|
|
/// at the given offset in the bitstream. It is a helper routine for
|
|
|
|
/// GetType, which deals with reading type IDs.
|
|
|
|
QualType PCHReader::ReadTypeRecord(uint64_t Offset) {
|
2009-04-15 01:18:50 +04:00
|
|
|
// Keep track of where we are in the stream, then jump back there
|
|
|
|
// after reading this type.
|
|
|
|
SavedStreamPosition SavedPosition(Stream);
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
Stream.JumpToBit(Offset);
|
|
|
|
RecordData Record;
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
switch ((pch::TypeCode)Stream.ReadRecord(Code, Record)) {
|
2009-04-16 02:00:08 +04:00
|
|
|
case pch::TYPE_EXT_QUAL: {
|
|
|
|
assert(Record.size() == 3 &&
|
|
|
|
"Incorrect encoding of extended qualifier type");
|
|
|
|
QualType Base = GetType(Record[0]);
|
|
|
|
QualType::GCAttrTypes GCAttr = (QualType::GCAttrTypes)Record[1];
|
|
|
|
unsigned AddressSpace = Record[2];
|
|
|
|
|
|
|
|
QualType T = Base;
|
|
|
|
if (GCAttr != QualType::GCNone)
|
|
|
|
T = Context.getObjCGCQualType(T, GCAttr);
|
|
|
|
if (AddressSpace)
|
|
|
|
T = Context.getAddrSpaceQualType(T, AddressSpace);
|
|
|
|
return T;
|
|
|
|
}
|
2009-04-14 00:46:52 +04:00
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
case pch::TYPE_FIXED_WIDTH_INT: {
|
|
|
|
assert(Record.size() == 2 && "Incorrect encoding of fixed-width int type");
|
|
|
|
return Context.getFixedWidthIntType(Record[0], Record[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_COMPLEX: {
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of complex type");
|
|
|
|
QualType ElemType = GetType(Record[0]);
|
|
|
|
return Context.getComplexType(ElemType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_POINTER: {
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of pointer type");
|
|
|
|
QualType PointeeType = GetType(Record[0]);
|
|
|
|
return Context.getPointerType(PointeeType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_BLOCK_POINTER: {
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of block pointer type");
|
|
|
|
QualType PointeeType = GetType(Record[0]);
|
|
|
|
return Context.getBlockPointerType(PointeeType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_LVALUE_REFERENCE: {
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of lvalue reference type");
|
|
|
|
QualType PointeeType = GetType(Record[0]);
|
|
|
|
return Context.getLValueReferenceType(PointeeType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_RVALUE_REFERENCE: {
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of rvalue reference type");
|
|
|
|
QualType PointeeType = GetType(Record[0]);
|
|
|
|
return Context.getRValueReferenceType(PointeeType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_MEMBER_POINTER: {
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of member pointer type");
|
|
|
|
QualType PointeeType = GetType(Record[0]);
|
|
|
|
QualType ClassType = GetType(Record[1]);
|
|
|
|
return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
|
|
|
|
}
|
|
|
|
|
2009-04-14 00:46:52 +04:00
|
|
|
case pch::TYPE_CONSTANT_ARRAY: {
|
|
|
|
QualType ElementType = GetType(Record[0]);
|
|
|
|
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
|
|
|
|
unsigned IndexTypeQuals = Record[2];
|
|
|
|
unsigned Idx = 3;
|
|
|
|
llvm::APInt Size = ReadAPInt(Record, Idx);
|
|
|
|
return Context.getConstantArrayType(ElementType, Size, ASM, IndexTypeQuals);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_INCOMPLETE_ARRAY: {
|
|
|
|
QualType ElementType = GetType(Record[0]);
|
|
|
|
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
|
|
|
|
unsigned IndexTypeQuals = Record[2];
|
|
|
|
return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_VARIABLE_ARRAY: {
|
2009-04-15 01:18:50 +04:00
|
|
|
QualType ElementType = GetType(Record[0]);
|
|
|
|
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
|
|
|
|
unsigned IndexTypeQuals = Record[2];
|
|
|
|
return Context.getVariableArrayType(ElementType, ReadExpr(),
|
|
|
|
ASM, IndexTypeQuals);
|
2009-04-14 00:46:52 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_VECTOR: {
|
|
|
|
if (Record.size() != 2) {
|
|
|
|
Error("Incorrect encoding of vector type in PCH file");
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ElementType = GetType(Record[0]);
|
|
|
|
unsigned NumElements = Record[1];
|
|
|
|
return Context.getVectorType(ElementType, NumElements);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_EXT_VECTOR: {
|
|
|
|
if (Record.size() != 2) {
|
|
|
|
Error("Incorrect encoding of extended vector type in PCH file");
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType ElementType = GetType(Record[0]);
|
|
|
|
unsigned NumElements = Record[1];
|
|
|
|
return Context.getExtVectorType(ElementType, NumElements);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_FUNCTION_NO_PROTO: {
|
|
|
|
if (Record.size() != 1) {
|
|
|
|
Error("Incorrect encoding of no-proto function type");
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
QualType ResultType = GetType(Record[0]);
|
|
|
|
return Context.getFunctionNoProtoType(ResultType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_FUNCTION_PROTO: {
|
|
|
|
QualType ResultType = GetType(Record[0]);
|
|
|
|
unsigned Idx = 1;
|
|
|
|
unsigned NumParams = Record[Idx++];
|
|
|
|
llvm::SmallVector<QualType, 16> ParamTypes;
|
|
|
|
for (unsigned I = 0; I != NumParams; ++I)
|
|
|
|
ParamTypes.push_back(GetType(Record[Idx++]));
|
|
|
|
bool isVariadic = Record[Idx++];
|
|
|
|
unsigned Quals = Record[Idx++];
|
|
|
|
return Context.getFunctionType(ResultType, &ParamTypes[0], NumParams,
|
|
|
|
isVariadic, Quals);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_TYPEDEF:
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of typedef type");
|
|
|
|
return Context.getTypeDeclType(cast<TypedefDecl>(GetDecl(Record[0])));
|
|
|
|
|
|
|
|
case pch::TYPE_TYPEOF_EXPR:
|
2009-04-15 01:18:50 +04:00
|
|
|
return Context.getTypeOfExprType(ReadExpr());
|
2009-04-14 00:46:52 +04:00
|
|
|
|
|
|
|
case pch::TYPE_TYPEOF: {
|
|
|
|
if (Record.size() != 1) {
|
|
|
|
Error("Incorrect encoding of typeof(type) in PCH file");
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
QualType UnderlyingType = GetType(Record[0]);
|
|
|
|
return Context.getTypeOfType(UnderlyingType);
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::TYPE_RECORD:
|
2009-04-14 01:20:57 +04:00
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of record type");
|
|
|
|
return Context.getTypeDeclType(cast<RecordDecl>(GetDecl(Record[0])));
|
2009-04-14 00:46:52 +04:00
|
|
|
|
2009-04-13 22:14:40 +04:00
|
|
|
case pch::TYPE_ENUM:
|
|
|
|
assert(Record.size() == 1 && "Incorrect encoding of enum type");
|
|
|
|
return Context.getTypeDeclType(cast<EnumDecl>(GetDecl(Record[0])));
|
|
|
|
|
2009-04-14 00:46:52 +04:00
|
|
|
case pch::TYPE_OBJC_INTERFACE:
|
|
|
|
// FIXME: Deserialize ObjCInterfaceType
|
|
|
|
assert(false && "Cannot de-serialize ObjC interface types yet");
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
case pch::TYPE_OBJC_QUALIFIED_INTERFACE:
|
|
|
|
// FIXME: Deserialize ObjCQualifiedInterfaceType
|
|
|
|
assert(false && "Cannot de-serialize ObjC qualified interface types yet");
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
case pch::TYPE_OBJC_QUALIFIED_ID:
|
|
|
|
// FIXME: Deserialize ObjCQualifiedIdType
|
|
|
|
assert(false && "Cannot de-serialize ObjC qualified id types yet");
|
|
|
|
return QualType();
|
|
|
|
|
|
|
|
case pch::TYPE_OBJC_QUALIFIED_CLASS:
|
|
|
|
// FIXME: Deserialize ObjCQualifiedClassType
|
|
|
|
assert(false && "Cannot de-serialize ObjC qualified class types yet");
|
|
|
|
return QualType();
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Suppress a GCC warning
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Note that we have loaded the declaration with the given
|
|
|
|
/// Index.
|
|
|
|
///
|
|
|
|
/// This routine notes that this declaration has already been loaded,
|
|
|
|
/// so that future GetDecl calls will return this declaration rather
|
|
|
|
/// than trying to load a new declaration.
|
|
|
|
inline void PCHReader::LoadedDecl(unsigned Index, Decl *D) {
|
|
|
|
assert(!DeclAlreadyLoaded[Index] && "Decl loaded twice?");
|
|
|
|
DeclAlreadyLoaded[Index] = true;
|
|
|
|
DeclOffsets[Index] = reinterpret_cast<uint64_t>(D);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Read the declaration at the given offset from the PCH file.
|
|
|
|
Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) {
|
2009-04-15 01:18:50 +04:00
|
|
|
// Keep track of where we are in the stream, then jump back there
|
|
|
|
// after reading this declaration.
|
|
|
|
SavedStreamPosition SavedPosition(Stream);
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
Decl *D = 0;
|
|
|
|
Stream.JumpToBit(Offset);
|
|
|
|
RecordData Record;
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
unsigned Idx = 0;
|
|
|
|
PCHDeclReader Reader(*this, Record, Idx);
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
switch ((pch::DeclCode)Stream.ReadRecord(Code, Record)) {
|
2009-04-16 01:30:51 +04:00
|
|
|
case pch::DECL_ATTR:
|
|
|
|
case pch::DECL_CONTEXT_LEXICAL:
|
|
|
|
case pch::DECL_CONTEXT_VISIBLE:
|
|
|
|
assert(false && "Record cannot be de-serialized with ReadDeclRecord");
|
|
|
|
break;
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
case pch::DECL_TRANSLATION_UNIT:
|
|
|
|
assert(Index == 0 && "Translation unit must be at index 0");
|
|
|
|
D = Context.getTranslationUnitDecl();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::DECL_TYPEDEF: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = TypedefDecl::Create(Context, 0, SourceLocation(), 0, QualType());
|
2009-04-10 02:27:44 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-13 22:14:40 +04:00
|
|
|
case pch::DECL_ENUM: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = EnumDecl::Create(Context, 0, SourceLocation(), 0, 0);
|
2009-04-13 22:14:40 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-14 01:20:57 +04:00
|
|
|
case pch::DECL_RECORD: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = RecordDecl::Create(Context, TagDecl::TK_struct, 0, SourceLocation(),
|
|
|
|
0, 0);
|
2009-04-14 01:20:57 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-13 22:14:40 +04:00
|
|
|
case pch::DECL_ENUM_CONSTANT: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = EnumConstantDecl::Create(Context, 0, SourceLocation(), 0, QualType(),
|
|
|
|
0, llvm::APSInt());
|
2009-04-13 22:14:40 +04:00
|
|
|
break;
|
|
|
|
}
|
2009-04-14 02:18:37 +04:00
|
|
|
|
|
|
|
case pch::DECL_FUNCTION: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = FunctionDecl::Create(Context, 0, SourceLocation(), DeclarationName(),
|
|
|
|
QualType());
|
2009-04-14 02:18:37 +04:00
|
|
|
break;
|
|
|
|
}
|
2009-04-13 22:14:40 +04:00
|
|
|
|
2009-04-14 01:20:57 +04:00
|
|
|
case pch::DECL_FIELD: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = FieldDecl::Create(Context, 0, SourceLocation(), 0, QualType(), 0,
|
|
|
|
false);
|
2009-04-14 01:20:57 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
case pch::DECL_VAR: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = VarDecl::Create(Context, 0, SourceLocation(), 0, QualType(),
|
|
|
|
VarDecl::None, SourceLocation());
|
2009-04-14 02:18:37 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DECL_PARM_VAR: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = ParmVarDecl::Create(Context, 0, SourceLocation(), 0, QualType(),
|
|
|
|
VarDecl::None, 0);
|
2009-04-14 02:18:37 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DECL_ORIGINAL_PARM_VAR: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = OriginalParmVarDecl::Create(Context, 0, SourceLocation(), 0,
|
2009-04-14 02:18:37 +04:00
|
|
|
QualType(), QualType(), VarDecl::None,
|
|
|
|
0);
|
2009-04-14 02:49:25 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DECL_FILE_SCOPE_ASM: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = FileScopeAsmDecl::Create(Context, 0, SourceLocation(), 0);
|
2009-04-14 02:49:25 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case pch::DECL_BLOCK: {
|
2009-04-17 02:29:51 +04:00
|
|
|
D = BlockDecl::Create(Context, 0, SourceLocation());
|
2009-04-10 02:27:44 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-17 02:29:51 +04:00
|
|
|
assert(D && "Unknown declaration creating PCH file");
|
|
|
|
if (D) {
|
|
|
|
LoadedDecl(Index, D);
|
|
|
|
Reader.Visit(D);
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
// If this declaration is also a declaration context, get the
|
|
|
|
// offsets for its tables of lexical and visible declarations.
|
|
|
|
if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
|
|
|
|
std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
|
|
|
|
if (Offsets.first || Offsets.second) {
|
|
|
|
DC->setHasExternalLexicalStorage(Offsets.first != 0);
|
|
|
|
DC->setHasExternalVisibleStorage(Offsets.second != 0);
|
|
|
|
DeclContextOffsets[DC] = Offsets;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(Idx == Record.size());
|
|
|
|
|
|
|
|
return D;
|
|
|
|
}
|
|
|
|
|
2009-04-10 21:25:41 +04:00
|
|
|
QualType PCHReader::GetType(pch::TypeID ID) {
|
2009-04-10 02:27:44 +04:00
|
|
|
unsigned Quals = ID & 0x07;
|
|
|
|
unsigned Index = ID >> 3;
|
|
|
|
|
|
|
|
if (Index < pch::NUM_PREDEF_TYPE_IDS) {
|
|
|
|
QualType T;
|
|
|
|
switch ((pch::PredefinedTypeIDs)Index) {
|
|
|
|
case pch::PREDEF_TYPE_NULL_ID: return QualType();
|
|
|
|
case pch::PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
|
|
|
|
case pch::PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
|
|
|
|
|
|
|
|
case pch::PREDEF_TYPE_CHAR_U_ID:
|
|
|
|
case pch::PREDEF_TYPE_CHAR_S_ID:
|
|
|
|
// FIXME: Check that the signedness of CharTy is correct!
|
|
|
|
T = Context.CharTy;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break;
|
|
|
|
case pch::PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break;
|
|
|
|
case pch::PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break;
|
|
|
|
case pch::PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break;
|
|
|
|
case pch::PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break;
|
|
|
|
case pch::PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break;
|
|
|
|
case pch::PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break;
|
|
|
|
case pch::PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break;
|
|
|
|
case pch::PREDEF_TYPE_INT_ID: T = Context.IntTy; break;
|
|
|
|
case pch::PREDEF_TYPE_LONG_ID: T = Context.LongTy; break;
|
|
|
|
case pch::PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break;
|
|
|
|
case pch::PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break;
|
|
|
|
case pch::PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break;
|
|
|
|
case pch::PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break;
|
|
|
|
case pch::PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break;
|
|
|
|
case pch::PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(!T.isNull() && "Unknown predefined type");
|
|
|
|
return T.getQualifiedType(Quals);
|
|
|
|
}
|
|
|
|
|
|
|
|
Index -= pch::NUM_PREDEF_TYPE_IDS;
|
|
|
|
if (!TypeAlreadyLoaded[Index]) {
|
|
|
|
// Load the type from the PCH file.
|
|
|
|
TypeOffsets[Index] = reinterpret_cast<uint64_t>(
|
|
|
|
ReadTypeRecord(TypeOffsets[Index]).getTypePtr());
|
|
|
|
TypeAlreadyLoaded[Index] = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return QualType(reinterpret_cast<Type *>(TypeOffsets[Index]), Quals);
|
|
|
|
}
|
|
|
|
|
2009-04-10 21:25:41 +04:00
|
|
|
Decl *PCHReader::GetDecl(pch::DeclID ID) {
|
2009-04-10 02:27:44 +04:00
|
|
|
if (ID == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
unsigned Index = ID - 1;
|
|
|
|
if (DeclAlreadyLoaded[Index])
|
|
|
|
return reinterpret_cast<Decl *>(DeclOffsets[Index]);
|
|
|
|
|
|
|
|
// Load the declaration from the PCH file.
|
|
|
|
return ReadDeclRecord(DeclOffsets[Index], Index);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool PCHReader::ReadDeclsLexicallyInContext(DeclContext *DC,
|
2009-04-10 21:25:41 +04:00
|
|
|
llvm::SmallVectorImpl<pch::DeclID> &Decls) {
|
2009-04-10 02:27:44 +04:00
|
|
|
assert(DC->hasExternalLexicalStorage() &&
|
|
|
|
"DeclContext has no lexical decls in storage");
|
|
|
|
uint64_t Offset = DeclContextOffsets[DC].first;
|
|
|
|
assert(Offset && "DeclContext has no lexical decls in storage");
|
|
|
|
|
2009-04-15 01:18:50 +04:00
|
|
|
// Keep track of where we are in the stream, then jump back there
|
|
|
|
// after reading this context.
|
|
|
|
SavedStreamPosition SavedPosition(Stream);
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
// Load the record containing all of the declarations lexically in
|
|
|
|
// this context.
|
|
|
|
Stream.JumpToBit(Offset);
|
|
|
|
RecordData Record;
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
unsigned RecCode = Stream.ReadRecord(Code, Record);
|
2009-04-15 22:43:11 +04:00
|
|
|
(void)RecCode;
|
2009-04-10 02:27:44 +04:00
|
|
|
assert(RecCode == pch::DECL_CONTEXT_LEXICAL && "Expected lexical block");
|
|
|
|
|
|
|
|
// Load all of the declaration IDs
|
|
|
|
Decls.clear();
|
|
|
|
Decls.insert(Decls.end(), Record.begin(), Record.end());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool PCHReader::ReadDeclsVisibleInContext(DeclContext *DC,
|
|
|
|
llvm::SmallVectorImpl<VisibleDeclaration> & Decls) {
|
|
|
|
assert(DC->hasExternalVisibleStorage() &&
|
|
|
|
"DeclContext has no visible decls in storage");
|
|
|
|
uint64_t Offset = DeclContextOffsets[DC].second;
|
|
|
|
assert(Offset && "DeclContext has no visible decls in storage");
|
|
|
|
|
2009-04-15 01:18:50 +04:00
|
|
|
// Keep track of where we are in the stream, then jump back there
|
|
|
|
// after reading this context.
|
|
|
|
SavedStreamPosition SavedPosition(Stream);
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
// Load the record containing all of the declarations visible in
|
|
|
|
// this context.
|
|
|
|
Stream.JumpToBit(Offset);
|
|
|
|
RecordData Record;
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
unsigned RecCode = Stream.ReadRecord(Code, Record);
|
2009-04-15 22:43:11 +04:00
|
|
|
(void)RecCode;
|
2009-04-10 02:27:44 +04:00
|
|
|
assert(RecCode == pch::DECL_CONTEXT_VISIBLE && "Expected visible block");
|
|
|
|
if (Record.size() == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Decls.clear();
|
|
|
|
|
|
|
|
unsigned Idx = 0;
|
|
|
|
while (Idx < Record.size()) {
|
|
|
|
Decls.push_back(VisibleDeclaration());
|
|
|
|
Decls.back().Name = ReadDeclarationName(Record, Idx);
|
|
|
|
|
|
|
|
unsigned Size = Record[Idx++];
|
|
|
|
llvm::SmallVector<unsigned, 4> & LoadedDecls
|
|
|
|
= Decls.back().Declarations;
|
|
|
|
LoadedDecls.reserve(Size);
|
|
|
|
for (unsigned I = 0; I < Size; ++I)
|
|
|
|
LoadedDecls.push_back(Record[Idx++]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-04-14 04:24:19 +04:00
|
|
|
void PCHReader::StartTranslationUnit(ASTConsumer *Consumer) {
|
|
|
|
if (!Consumer)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
|
|
|
|
Decl *D = GetDecl(ExternalDefinitions[I]);
|
|
|
|
DeclGroupRef DG(D);
|
|
|
|
Consumer->HandleTopLevelDecl(DG);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
void PCHReader::PrintStats() {
|
|
|
|
std::fprintf(stderr, "*** PCH Statistics:\n");
|
|
|
|
|
|
|
|
unsigned NumTypesLoaded = std::count(TypeAlreadyLoaded.begin(),
|
|
|
|
TypeAlreadyLoaded.end(),
|
|
|
|
true);
|
|
|
|
unsigned NumDeclsLoaded = std::count(DeclAlreadyLoaded.begin(),
|
|
|
|
DeclAlreadyLoaded.end(),
|
|
|
|
true);
|
2009-04-14 00:50:16 +04:00
|
|
|
unsigned NumIdentifiersLoaded = 0;
|
|
|
|
for (unsigned I = 0; I < IdentifierData.size(); ++I) {
|
|
|
|
if ((IdentifierData[I] & 0x01) == 0)
|
|
|
|
++NumIdentifiersLoaded;
|
|
|
|
}
|
|
|
|
|
2009-04-10 02:27:44 +04:00
|
|
|
std::fprintf(stderr, " %u/%u types read (%f%%)\n",
|
|
|
|
NumTypesLoaded, (unsigned)TypeAlreadyLoaded.size(),
|
2009-04-14 00:50:16 +04:00
|
|
|
((float)NumTypesLoaded/TypeAlreadyLoaded.size() * 100));
|
2009-04-10 02:27:44 +04:00
|
|
|
std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
|
|
|
|
NumDeclsLoaded, (unsigned)DeclAlreadyLoaded.size(),
|
2009-04-14 00:50:16 +04:00
|
|
|
((float)NumDeclsLoaded/DeclAlreadyLoaded.size() * 100));
|
|
|
|
std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
|
|
|
|
NumIdentifiersLoaded, (unsigned)IdentifierData.size(),
|
|
|
|
((float)NumIdentifiersLoaded/IdentifierData.size() * 100));
|
2009-04-10 02:27:44 +04:00
|
|
|
std::fprintf(stderr, "\n");
|
|
|
|
}
|
|
|
|
|
2009-04-12 01:15:38 +04:00
|
|
|
IdentifierInfo *PCHReader::DecodeIdentifierInfo(unsigned ID) {
|
2009-04-11 04:14:32 +04:00
|
|
|
if (ID == 0)
|
|
|
|
return 0;
|
2009-04-12 01:15:38 +04:00
|
|
|
|
2009-04-11 04:14:32 +04:00
|
|
|
if (!IdentifierTable || IdentifierData.empty()) {
|
|
|
|
Error("No identifier table in PCH file");
|
|
|
|
return 0;
|
|
|
|
}
|
2009-04-12 01:15:38 +04:00
|
|
|
|
2009-04-11 04:14:32 +04:00
|
|
|
if (IdentifierData[ID - 1] & 0x01) {
|
|
|
|
uint64_t Offset = IdentifierData[ID - 1];
|
|
|
|
IdentifierData[ID - 1] = reinterpret_cast<uint64_t>(
|
2009-04-12 01:15:38 +04:00
|
|
|
&Context.Idents.get(IdentifierTable + Offset));
|
2009-04-11 04:14:32 +04:00
|
|
|
}
|
2009-04-12 01:15:38 +04:00
|
|
|
|
|
|
|
return reinterpret_cast<IdentifierInfo *>(IdentifierData[ID - 1]);
|
2009-04-10 02:27:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
DeclarationName
|
|
|
|
PCHReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) {
|
|
|
|
DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
|
|
|
|
switch (Kind) {
|
|
|
|
case DeclarationName::Identifier:
|
|
|
|
return DeclarationName(GetIdentifierInfo(Record, Idx));
|
|
|
|
|
|
|
|
case DeclarationName::ObjCZeroArgSelector:
|
|
|
|
case DeclarationName::ObjCOneArgSelector:
|
|
|
|
case DeclarationName::ObjCMultiArgSelector:
|
|
|
|
assert(false && "Unable to de-serialize Objective-C selectors");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DeclarationName::CXXConstructorName:
|
|
|
|
return Context.DeclarationNames.getCXXConstructorName(
|
|
|
|
GetType(Record[Idx++]));
|
|
|
|
|
|
|
|
case DeclarationName::CXXDestructorName:
|
|
|
|
return Context.DeclarationNames.getCXXDestructorName(
|
|
|
|
GetType(Record[Idx++]));
|
|
|
|
|
|
|
|
case DeclarationName::CXXConversionFunctionName:
|
|
|
|
return Context.DeclarationNames.getCXXConversionFunctionName(
|
|
|
|
GetType(Record[Idx++]));
|
|
|
|
|
|
|
|
case DeclarationName::CXXOperatorName:
|
|
|
|
return Context.DeclarationNames.getCXXOperatorName(
|
|
|
|
(OverloadedOperatorKind)Record[Idx++]);
|
|
|
|
|
|
|
|
case DeclarationName::CXXUsingDirective:
|
|
|
|
return DeclarationName::getUsingDirectiveName();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Required to silence GCC warning
|
|
|
|
return DeclarationName();
|
|
|
|
}
|
2009-04-11 00:39:37 +04:00
|
|
|
|
2009-04-13 22:14:40 +04:00
|
|
|
/// \brief Read an integral value
|
|
|
|
llvm::APInt PCHReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
|
|
|
|
unsigned BitWidth = Record[Idx++];
|
|
|
|
unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
|
|
|
|
llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
|
|
|
|
Idx += NumWords;
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Read a signed integral value
|
|
|
|
llvm::APSInt PCHReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
|
|
|
|
bool isUnsigned = Record[Idx++];
|
|
|
|
return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
|
|
|
|
}
|
|
|
|
|
2009-04-15 01:55:33 +04:00
|
|
|
/// \brief Read a floating-point value
|
|
|
|
llvm::APFloat PCHReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
|
|
|
|
return llvm::APFloat(ReadAPInt(Record, Idx));
|
|
|
|
}
|
|
|
|
|
2009-04-16 01:30:51 +04:00
|
|
|
// \brief Read a string
|
|
|
|
std::string PCHReader::ReadString(const RecordData &Record, unsigned &Idx) {
|
|
|
|
unsigned Len = Record[Idx++];
|
|
|
|
std::string Result(&Record[Idx], &Record[Idx] + Len);
|
|
|
|
Idx += Len;
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Reads attributes from the current stream position.
|
|
|
|
Attr *PCHReader::ReadAttributes() {
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
assert(Code == llvm::bitc::UNABBREV_RECORD &&
|
|
|
|
"Expected unabbreviated record"); (void)Code;
|
|
|
|
|
|
|
|
RecordData Record;
|
|
|
|
unsigned Idx = 0;
|
|
|
|
unsigned RecCode = Stream.ReadRecord(Code, Record);
|
|
|
|
assert(RecCode == pch::DECL_ATTR && "Expected attribute record");
|
|
|
|
(void)RecCode;
|
|
|
|
|
|
|
|
#define SIMPLE_ATTR(Name) \
|
|
|
|
case Attr::Name: \
|
|
|
|
New = ::new (Context) Name##Attr(); \
|
|
|
|
break
|
|
|
|
|
|
|
|
#define STRING_ATTR(Name) \
|
|
|
|
case Attr::Name: \
|
|
|
|
New = ::new (Context) Name##Attr(ReadString(Record, Idx)); \
|
|
|
|
break
|
|
|
|
|
|
|
|
#define UNSIGNED_ATTR(Name) \
|
|
|
|
case Attr::Name: \
|
|
|
|
New = ::new (Context) Name##Attr(Record[Idx++]); \
|
|
|
|
break
|
|
|
|
|
|
|
|
Attr *Attrs = 0;
|
|
|
|
while (Idx < Record.size()) {
|
|
|
|
Attr *New = 0;
|
|
|
|
Attr::Kind Kind = (Attr::Kind)Record[Idx++];
|
|
|
|
bool IsInherited = Record[Idx++];
|
|
|
|
|
|
|
|
switch (Kind) {
|
|
|
|
STRING_ATTR(Alias);
|
|
|
|
UNSIGNED_ATTR(Aligned);
|
|
|
|
SIMPLE_ATTR(AlwaysInline);
|
|
|
|
SIMPLE_ATTR(AnalyzerNoReturn);
|
|
|
|
STRING_ATTR(Annotate);
|
|
|
|
STRING_ATTR(AsmLabel);
|
|
|
|
|
|
|
|
case Attr::Blocks:
|
|
|
|
New = ::new (Context) BlocksAttr(
|
|
|
|
(BlocksAttr::BlocksAttrTypes)Record[Idx++]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Attr::Cleanup:
|
|
|
|
New = ::new (Context) CleanupAttr(
|
|
|
|
cast<FunctionDecl>(GetDecl(Record[Idx++])));
|
|
|
|
break;
|
|
|
|
|
|
|
|
SIMPLE_ATTR(Const);
|
|
|
|
UNSIGNED_ATTR(Constructor);
|
|
|
|
SIMPLE_ATTR(DLLExport);
|
|
|
|
SIMPLE_ATTR(DLLImport);
|
|
|
|
SIMPLE_ATTR(Deprecated);
|
|
|
|
UNSIGNED_ATTR(Destructor);
|
|
|
|
SIMPLE_ATTR(FastCall);
|
|
|
|
|
|
|
|
case Attr::Format: {
|
|
|
|
std::string Type = ReadString(Record, Idx);
|
|
|
|
unsigned FormatIdx = Record[Idx++];
|
|
|
|
unsigned FirstArg = Record[Idx++];
|
|
|
|
New = ::new (Context) FormatAttr(Type, FormatIdx, FirstArg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
SIMPLE_ATTR(GNUCInline);
|
|
|
|
|
|
|
|
case Attr::IBOutletKind:
|
|
|
|
New = ::new (Context) IBOutletAttr();
|
|
|
|
break;
|
|
|
|
|
|
|
|
SIMPLE_ATTR(NoReturn);
|
|
|
|
SIMPLE_ATTR(NoThrow);
|
|
|
|
SIMPLE_ATTR(Nodebug);
|
|
|
|
SIMPLE_ATTR(Noinline);
|
|
|
|
|
|
|
|
case Attr::NonNull: {
|
|
|
|
unsigned Size = Record[Idx++];
|
|
|
|
llvm::SmallVector<unsigned, 16> ArgNums;
|
|
|
|
ArgNums.insert(ArgNums.end(), &Record[Idx], &Record[Idx] + Size);
|
|
|
|
Idx += Size;
|
|
|
|
New = ::new (Context) NonNullAttr(&ArgNums[0], Size);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
SIMPLE_ATTR(ObjCException);
|
|
|
|
SIMPLE_ATTR(ObjCNSObject);
|
|
|
|
SIMPLE_ATTR(Overloadable);
|
|
|
|
UNSIGNED_ATTR(Packed);
|
|
|
|
SIMPLE_ATTR(Pure);
|
|
|
|
UNSIGNED_ATTR(Regparm);
|
|
|
|
STRING_ATTR(Section);
|
|
|
|
SIMPLE_ATTR(StdCall);
|
|
|
|
SIMPLE_ATTR(TransparentUnion);
|
|
|
|
SIMPLE_ATTR(Unavailable);
|
|
|
|
SIMPLE_ATTR(Unused);
|
|
|
|
SIMPLE_ATTR(Used);
|
|
|
|
|
|
|
|
case Attr::Visibility:
|
|
|
|
New = ::new (Context) VisibilityAttr(
|
|
|
|
(VisibilityAttr::VisibilityTypes)Record[Idx++]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
SIMPLE_ATTR(WarnUnusedResult);
|
|
|
|
SIMPLE_ATTR(Weak);
|
|
|
|
SIMPLE_ATTR(WeakImport);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(New && "Unable to decode attribute?");
|
|
|
|
New->setInherited(IsInherited);
|
|
|
|
New->setNext(Attrs);
|
|
|
|
Attrs = New;
|
|
|
|
}
|
|
|
|
#undef UNSIGNED_ATTR
|
|
|
|
#undef STRING_ATTR
|
|
|
|
#undef SIMPLE_ATTR
|
|
|
|
|
|
|
|
// The list of attributes was built backwards. Reverse the list
|
|
|
|
// before returning it.
|
|
|
|
Attr *PrevAttr = 0, *NextAttr = 0;
|
|
|
|
while (Attrs) {
|
|
|
|
NextAttr = Attrs->getNext();
|
|
|
|
Attrs->setNext(PrevAttr);
|
|
|
|
PrevAttr = Attrs;
|
|
|
|
Attrs = NextAttr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return PrevAttr;
|
|
|
|
}
|
|
|
|
|
2009-04-17 02:23:12 +04:00
|
|
|
Stmt *PCHReader::ReadStmt() {
|
2009-04-15 03:32:43 +04:00
|
|
|
// Within the bitstream, expressions are stored in Reverse Polish
|
|
|
|
// Notation, with each of the subexpressions preceding the
|
|
|
|
// expression they are stored in. To evaluate expressions, we
|
|
|
|
// continue reading expressions and placing them on the stack, with
|
|
|
|
// expressions having operands removing those operands from the
|
2009-04-17 02:23:12 +04:00
|
|
|
// stack. Evaluation terminates when we see a STMT_STOP record, and
|
2009-04-15 03:32:43 +04:00
|
|
|
// the single remaining expression on the stack is our result.
|
2009-04-15 01:18:50 +04:00
|
|
|
RecordData Record;
|
2009-04-15 03:32:43 +04:00
|
|
|
unsigned Idx;
|
2009-04-17 02:23:12 +04:00
|
|
|
llvm::SmallVector<Stmt *, 16> StmtStack;
|
|
|
|
PCHStmtReader Reader(*this, Record, Idx, StmtStack);
|
2009-04-15 01:18:50 +04:00
|
|
|
Stmt::EmptyShell Empty;
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
while (true) {
|
|
|
|
unsigned Code = Stream.ReadCode();
|
|
|
|
if (Code == llvm::bitc::END_BLOCK) {
|
|
|
|
if (Stream.ReadBlockEnd()) {
|
|
|
|
Error("Error at end of Source Manager block");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
|
|
|
|
// No known subblocks, always skip them.
|
|
|
|
Stream.ReadSubBlockID();
|
|
|
|
if (Stream.SkipBlock()) {
|
|
|
|
Error("Malformed block record");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
2009-04-15 01:55:33 +04:00
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
if (Code == llvm::bitc::DEFINE_ABBREV) {
|
|
|
|
Stream.ReadAbbrevRecord();
|
|
|
|
continue;
|
|
|
|
}
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-17 02:23:12 +04:00
|
|
|
Stmt *S = 0;
|
2009-04-15 03:32:43 +04:00
|
|
|
Idx = 0;
|
|
|
|
Record.clear();
|
|
|
|
bool Finished = false;
|
|
|
|
switch ((pch::StmtCode)Stream.ReadRecord(Code, Record)) {
|
2009-04-17 02:23:12 +04:00
|
|
|
case pch::STMT_STOP:
|
2009-04-15 03:32:43 +04:00
|
|
|
Finished = true;
|
|
|
|
break;
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-17 02:23:12 +04:00
|
|
|
case pch::STMT_NULL_PTR:
|
|
|
|
S = 0;
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-17 04:04:06 +04:00
|
|
|
case pch::STMT_NULL:
|
|
|
|
S = new (Context) NullStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::STMT_COMPOUND:
|
|
|
|
S = new (Context) CompoundStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::STMT_CASE:
|
|
|
|
S = new (Context) CaseStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::STMT_DEFAULT:
|
|
|
|
S = new (Context) DefaultStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::STMT_IF:
|
|
|
|
S = new (Context) IfStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::STMT_SWITCH:
|
|
|
|
S = new (Context) SwitchStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
2009-04-17 04:16:09 +04:00
|
|
|
case pch::STMT_WHILE:
|
|
|
|
S = new (Context) WhileStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
2009-04-17 04:29:51 +04:00
|
|
|
case pch::STMT_DO:
|
|
|
|
S = new (Context) DoStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::STMT_FOR:
|
|
|
|
S = new (Context) ForStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
2009-04-17 04:16:09 +04:00
|
|
|
case pch::STMT_CONTINUE:
|
|
|
|
S = new (Context) ContinueStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
2009-04-17 04:04:06 +04:00
|
|
|
case pch::STMT_BREAK:
|
|
|
|
S = new (Context) BreakStmt(Empty);
|
|
|
|
break;
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
case pch::EXPR_PREDEFINED:
|
|
|
|
// FIXME: untested (until we can serialize function bodies).
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) PredefinedExpr(Empty);
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_DECL_REF:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) DeclRefExpr(Empty);
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_INTEGER_LITERAL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) IntegerLiteral(Empty);
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_FLOATING_LITERAL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) FloatingLiteral(Empty);
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-16 02:19:53 +04:00
|
|
|
case pch::EXPR_IMAGINARY_LITERAL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ImaginaryLiteral(Empty);
|
2009-04-16 02:19:53 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-15 20:35:07 +04:00
|
|
|
case pch::EXPR_STRING_LITERAL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = StringLiteral::CreateEmpty(Context,
|
2009-04-15 20:35:07 +04:00
|
|
|
Record[PCHStmtReader::NumExprFields + 1]);
|
|
|
|
break;
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
case pch::EXPR_CHARACTER_LITERAL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) CharacterLiteral(Empty);
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-15 03:59:37 +04:00
|
|
|
case pch::EXPR_PAREN:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ParenExpr(Empty);
|
2009-04-15 03:59:37 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-15 19:58:59 +04:00
|
|
|
case pch::EXPR_UNARY_OPERATOR:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) UnaryOperator(Empty);
|
2009-04-15 19:58:59 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_SIZEOF_ALIGN_OF:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) SizeOfAlignOfExpr(Empty);
|
2009-04-15 19:58:59 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-16 02:19:53 +04:00
|
|
|
case pch::EXPR_ARRAY_SUBSCRIPT:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ArraySubscriptExpr(Empty);
|
2009-04-16 02:19:53 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-15 21:43:59 +04:00
|
|
|
case pch::EXPR_CALL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) CallExpr(Context, Empty);
|
2009-04-15 21:43:59 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_MEMBER:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) MemberExpr(Empty);
|
2009-04-15 21:43:59 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-15 04:25:59 +04:00
|
|
|
case pch::EXPR_BINARY_OPERATOR:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) BinaryOperator(Empty);
|
2009-04-16 02:40:36 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_COMPOUND_ASSIGN_OPERATOR:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) CompoundAssignOperator(Empty);
|
2009-04-16 02:40:36 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_CONDITIONAL_OPERATOR:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ConditionalOperator(Empty);
|
2009-04-15 04:25:59 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-15 03:32:43 +04:00
|
|
|
case pch::EXPR_IMPLICIT_CAST:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ImplicitCastExpr(Empty);
|
2009-04-15 03:32:43 +04:00
|
|
|
break;
|
2009-04-15 04:25:59 +04:00
|
|
|
|
|
|
|
case pch::EXPR_CSTYLE_CAST:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) CStyleCastExpr(Empty);
|
2009-04-15 04:25:59 +04:00
|
|
|
break;
|
2009-04-16 03:02:49 +04:00
|
|
|
|
2009-04-16 06:33:48 +04:00
|
|
|
case pch::EXPR_COMPOUND_LITERAL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) CompoundLiteralExpr(Empty);
|
2009-04-16 06:33:48 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-16 03:02:49 +04:00
|
|
|
case pch::EXPR_EXT_VECTOR_ELEMENT:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ExtVectorElementExpr(Empty);
|
2009-04-16 03:02:49 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-16 04:55:48 +04:00
|
|
|
case pch::EXPR_INIT_LIST:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) InitListExpr(Empty);
|
2009-04-16 04:55:48 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_DESIGNATED_INIT:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = DesignatedInitExpr::CreateEmpty(Context,
|
2009-04-16 04:55:48 +04:00
|
|
|
Record[PCHStmtReader::NumExprFields] - 1);
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_IMPLICIT_VALUE_INIT:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ImplicitValueInitExpr(Empty);
|
2009-04-16 04:55:48 +04:00
|
|
|
break;
|
|
|
|
|
2009-04-16 03:02:49 +04:00
|
|
|
case pch::EXPR_VA_ARG:
|
|
|
|
// FIXME: untested; we need function bodies first
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) VAArgExpr(Empty);
|
2009-04-16 03:02:49 +04:00
|
|
|
break;
|
2009-04-16 03:33:31 +04:00
|
|
|
|
|
|
|
case pch::EXPR_TYPES_COMPATIBLE:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) TypesCompatibleExpr(Empty);
|
2009-04-16 03:33:31 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_CHOOSE:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ChooseExpr(Empty);
|
2009-04-16 03:33:31 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_GNU_NULL:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) GNUNullExpr(Empty);
|
2009-04-16 03:33:31 +04:00
|
|
|
break;
|
2009-04-16 04:01:45 +04:00
|
|
|
|
|
|
|
case pch::EXPR_SHUFFLE_VECTOR:
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) ShuffleVectorExpr(Empty);
|
2009-04-16 04:01:45 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case pch::EXPR_BLOCK_DECL_REF:
|
|
|
|
// FIXME: untested until we have statement and block support
|
2009-04-17 02:23:12 +04:00
|
|
|
S = new (Context) BlockDeclRefExpr(Empty);
|
2009-04-16 04:01:45 +04:00
|
|
|
break;
|
2009-04-15 03:32:43 +04:00
|
|
|
}
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-17 02:23:12 +04:00
|
|
|
// We hit a STMT_STOP, so we're done with this expression.
|
2009-04-15 03:32:43 +04:00
|
|
|
if (Finished)
|
|
|
|
break;
|
2009-04-15 01:18:50 +04:00
|
|
|
|
2009-04-17 02:23:12 +04:00
|
|
|
if (S) {
|
|
|
|
unsigned NumSubStmts = Reader.Visit(S);
|
|
|
|
while (NumSubStmts > 0) {
|
|
|
|
StmtStack.pop_back();
|
|
|
|
--NumSubStmts;
|
2009-04-15 03:32:43 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(Idx == Record.size() && "Invalid deserialization of expression");
|
2009-04-17 02:23:12 +04:00
|
|
|
StmtStack.push_back(S);
|
2009-04-15 03:32:43 +04:00
|
|
|
}
|
2009-04-17 02:23:12 +04:00
|
|
|
assert(StmtStack.size() == 1 && "Extra expressions on stack!");
|
|
|
|
return StmtStack.back();
|
|
|
|
}
|
|
|
|
|
|
|
|
Expr *PCHReader::ReadExpr() {
|
|
|
|
return dyn_cast_or_null<Expr>(ReadStmt());
|
2009-04-15 01:18:50 +04:00
|
|
|
}
|
|
|
|
|
2009-04-11 00:39:37 +04:00
|
|
|
DiagnosticBuilder PCHReader::Diag(unsigned DiagID) {
|
2009-04-11 03:10:45 +04:00
|
|
|
return Diag(SourceLocation(), DiagID);
|
|
|
|
}
|
|
|
|
|
|
|
|
DiagnosticBuilder PCHReader::Diag(SourceLocation Loc, unsigned DiagID) {
|
|
|
|
return PP.getDiagnostics().Report(FullSourceLoc(Loc,
|
2009-04-11 00:39:37 +04:00
|
|
|
Context.getSourceManager()),
|
|
|
|
DiagID);
|
|
|
|
}
|
2009-04-17 04:04:06 +04:00
|
|
|
|
|
|
|
/// \brief Record that the given ID maps to the given switch-case
|
|
|
|
/// statement.
|
|
|
|
void PCHReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
|
|
|
|
assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
|
|
|
|
SwitchCaseStmts[ID] = SC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Retrieve the switch-case statement with the given ID.
|
|
|
|
SwitchCase *PCHReader::getSwitchCaseWithID(unsigned ID) {
|
|
|
|
assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
|
|
|
|
return SwitchCaseStmts[ID];
|
|
|
|
}
|