maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Serialization/ASTWriter.cpp

3201 lines
117 KiB
C++
Raw Normal View History

Rename the ASTWriter implementation files llvm-svn: 111465
2010-08-19 07:56:31 +08:00
//===--- ASTWriter.cpp - AST File Writer ----------------------------------===//
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
// This file defines the ASTWriter class, which writes AST files.
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
//
//===----------------------------------------------------------------------===//
Rename PCHWriter.h to ASTWriter.h llvm-svn: 111466
2010-08-19 07:56:37 +08:00
#include "clang/Serialization/ASTWriter.h"
Share the common code of ComputeHash(Selector Sel) instead of keeping 2 copies in PCHReader and PCHWriter. No functionality change. llvm-svn: 111629
2010-08-21 00:03:52 +08:00
#include "ASTCommon.h"
Move Sema's headers into include/clang/Sema, renaming a few along the way. llvm-svn: 110945
2010-08-13 04:07:10 +08:00
#include "clang/Sema/Sema.h"
#include "clang/Sema/IdentifierResolver.h"
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclContextInternals.h"
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
#include "clang/AST/DeclTemplate.h"
PCH support for a few very, very simple kinds of expressions. Hook up expression (de-)serialization for VLAs, variable initializers, enum constant initializers, and bitfield widths. llvm-svn: 69075
2009-04-15 05:18:50 +08:00
#include "clang/AST/Expr.h"
Remove a header dependency from Sema.h at the cost of some type safety. If someone wants to fix this some other way.... llvm-svn: 111905
2010-08-24 15:32:53 +08:00
#include "clang/AST/ExprCXX.h"
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
#include "clang/AST/Type.h"
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
#include "clang/AST/TypeLocVisitor.h"
Rename the ASTReader header files. llvm-svn: 111474
2010-08-19 07:57:17 +08:00
#include "clang/Serialization/ASTReader.h"
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
#include "clang/Lex/MacroInfo.h"
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
#include "clang/Lex/PreprocessingRecord.h"
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
#include "clang/Lex/Preprocessor.h"
Add PCH support for #import. llvm-svn: 69987
2009-04-25 04:03:17 +08:00
#include "clang/Lex/HeaderSearch.h"
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
#include "clang/Basic/FileManager.h"
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
#include "clang/Basic/OnDiskHashTable.h"
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
#include "clang/Basic/SourceManager.h"
Include the SourceManager's line table in the PCH file. We can now properly cope with #line directives in PCH files. llvm-svn: 68963
2009-04-14 00:31:14 +08:00
#include "clang/Basic/SourceManagerInternals.h"
Encode the target triple in the PCH file, and check that target triple when using the PCH file llvm-svn: 68824
2009-04-11 05:16:55 +08:00
#include "clang/Basic/TargetInfo.h"
Add a header containing the Clang version; make the driver use this Clang version value rather than hard-coding "1.0". Add PCH and Clang version information into the PCH file. Reject PCH files with the wrong version information. llvm-svn: 70264
2009-04-28 06:23:34 +08:00
#include "clang/Basic/Version.h"
Add PCH support for PredefinedExpr and FloatingLiteral expressions llvm-svn: 69084
2009-04-15 05:55:33 +08:00
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
Switch to llvm::HashString. llvm-svn: 84375
2009-10-18 07:52:28 +08:00
#include "llvm/ADT/StringExtras.h"
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
#include "llvm/Bitcode/BitstreamWriter.h"
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
#include "llvm/Support/MemoryBuffer.h"
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
#include "llvm/System/Path.h"
add some #includes for better compatibility with gcc 4.4, thanks to Tobias Stadler for pointing this out. llvm-svn: 68868
2009-04-12 02:40:46 +08:00
#include <cstdio>
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
using namespace clang;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
using namespace clang::serialization;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
template <typename T, typename Allocator>
T *data(std::vector<T, Allocator> &v) {
return v.empty() ? 0 : &v.front();
}
template <typename T, typename Allocator>
const T *data(const std::vector<T, Allocator> &v) {
return v.empty() ? 0 : &v.front();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
//===----------------------------------------------------------------------===//
// Type serialization
//===----------------------------------------------------------------------===//
split decl writing out to its own PCHWriterDecl.cpp file. llvm-svn: 70193
2009-04-27 14:16:06 +08:00
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
namespace {
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
class ASTTypeWriter {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter &Writer;
ASTWriter::RecordData &Record;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
public:
/// \brief Type code that corresponds to the record generated.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
TypeCode Code;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
: Writer(Writer), Record(Record), Code(TYPE_EXT_QUAL) { }
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
void VisitArrayType(const ArrayType *T);
void VisitFunctionType(const FunctionType *T);
void VisitTagType(const TagType *T);
#define TYPE(Class, Base) void Visit##Class##Type(const Class##Type *T);
#define ABSTRACT_TYPE(Class, Base)
#include "clang/AST/TypeNodes.def"
};
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
assert(false && "Built-in types are never serialized");
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getElementType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_COMPLEX;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitPointerType(const PointerType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_BLOCK_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_LVALUE_REFERENCE;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_RVALUE_REFERENCE;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitMemberPointerType(const MemberPointerType *T) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Writer.AddTypeRef(QualType(T->getClass(), 0), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_MEMBER_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitArrayType(const ArrayType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getElementType(), Record);
Record.push_back(T->getSizeModifier()); // FIXME: stable values
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
Record.push_back(T->getIndexTypeCVRQualifiers()); // FIXME: stable values
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitArrayType(T);
Writer.AddAPInt(T->getSize(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_CONSTANT_ARRAY;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitArrayType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_INCOMPLETE_ARRAY;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitArrayType(T);
Keep track of the Expr used to describe the size of an array type, from Enea Zaffanella! llvm-svn: 74831
2009-07-06 23:59:29 +08:00
Writer.AddSourceLocation(T->getLBracketLoc(), Record);
Writer.AddSourceLocation(T->getRBracketLoc(), Record);
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Writer.AddStmt(T->getSizeExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_VARIABLE_ARRAY;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitVectorType(const VectorType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getElementType(), Record);
Record.push_back(T->getNumElements());
improve altivec vector bool/pixel support, patch by Anton Yartsev with several tweaks by me. llvm-svn: 106619
2010-06-23 14:00:24 +08:00
Record.push_back(T->getAltiVecSpecific());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_VECTOR;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitExtVectorType(const ExtVectorType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitVectorType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_EXT_VECTOR;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitFunctionType(const FunctionType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getResultType(), Record);
the big refactoring bits of PR3782. This introduces FunctionType::ExtInfo to hold the calling convention and the noreturn attribute. The next patch will extend it to include the regparm attribute and fix the bug. llvm-svn: 99920
2010-03-31 04:24:48 +08:00
FunctionType::ExtInfo C = T->getExtInfo();
Record.push_back(C.getNoReturn());
Remember the regparm attribute in FunctionType::ExtInfo. Fixes PR3782. llvm-svn: 99940
2010-03-31 06:15:11 +08:00
Record.push_back(C.getRegParm());
Encoding calling conventions in the type system, from Charles Davis! llvm-svn: 93726
2010-01-19 01:14:39 +08:00
// FIXME: need to stabilize encoding of calling convention...
the big refactoring bits of PR3782. This introduces FunctionType::ExtInfo to hold the calling convention and the noreturn attribute. The next patch will extend it to include the regparm attribute and fix the bug. llvm-svn: 99920
2010-03-31 04:24:48 +08:00
Record.push_back(C.getCC());
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitFunctionType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_FUNCTION_NO_PROTO;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitFunctionProtoType(const FunctionProtoType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitFunctionType(T);
Record.push_back(T->getNumArgs());
for (unsigned I = 0, N = T->getNumArgs(); I != N; ++I)
Writer.AddTypeRef(T->getArgType(I), Record);
Record.push_back(T->isVariadic());
Record.push_back(T->getTypeQuals());
Reintroduce the home for exception specs, and make Sema fill it. However, keep the spec out of the canonical type this time. Net effect is currently nothing, because the spec isn't checked anywhere. llvm-svn: 72498
2009-05-28 06:11:52 +08:00
Record.push_back(T->hasExceptionSpec());
Record.push_back(T->hasAnyExceptionSpec());
Record.push_back(T->getNumExceptions());
for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
Writer.AddTypeRef(T->getExceptionType(I), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_FUNCTION_PROTO;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_UNRESOLVED_USING;
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
- Allow a typedef type to be read from PCH even if its decl is currently initializing. - Fix creation of TemplateSpecializationType. llvm-svn: 107471
2010-07-02 19:55:11 +08:00
assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TYPEDEF;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Writer.AddStmt(T->getUnderlyingExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TYPEOF_EXPR;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getUnderlyingType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TYPEOF;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
Add a DecltypeType type. llvm-svn: 74099
2009-06-25 03:06:50 +08:00
Writer.AddStmt(T->getUnderlyingExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_DECLTYPE;
Add a DecltypeType type. llvm-svn: 74099
2009-06-25 03:06:50 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTagType(const TagType *T) {
For TagType and TemplateSpecializationType, isDependent calculation may be invalid because some decls that the calculation is using may still be initializing. Thus, store the isDependent flag to PCH and restore directly to Type. llvm-svn: 107873
2010-07-08 21:09:53 +08:00
Record.push_back(T->isDependentType());
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(!T->isBeingDefined() &&
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
"Cannot serialize in the middle of a type definition");
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitRecordType(const RecordType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitTagType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_RECORD;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitEnumType(const EnumType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitTagType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_ENUM;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitSubstTemplateTypeParmType(
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
const SubstTemplateTypeParmType *T) {
Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
Writer.AddTypeRef(T->getReplacementType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_SUBST_TEMPLATE_TYPE_PARM;
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitTemplateSpecializationType(
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
const TemplateSpecializationType *T) {
For TagType and TemplateSpecializationType, isDependent calculation may be invalid because some decls that the calculation is using may still be initializing. Thus, store the isDependent flag to PCH and restore directly to Type. llvm-svn: 107873
2010-07-08 21:09:53 +08:00
Record.push_back(T->isDependentType());
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
Writer.AddTemplateName(T->getTemplateName(), Record);
Record.push_back(T->getNumArgs());
for (TemplateSpecializationType::iterator ArgI = T->begin(), ArgE = T->end();
ArgI != ArgE; ++ArgI)
Writer.AddTemplateArgument(*ArgI, Record);
- Allow a typedef type to be read from PCH even if its decl is currently initializing. - Fix creation of TemplateSpecializationType. llvm-svn: 107471
2010-07-02 19:55:11 +08:00
Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
: T->getCanonicalTypeInternal(),
Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TEMPLATE_SPECIALIZATION;
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
}
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
Support DependentSizedArrayType for PCH. llvm-svn: 107267
2010-06-30 16:49:25 +08:00
VisitArrayType(T);
Writer.AddStmt(T->getSizeExpr());
Writer.AddSourceRange(T->getBracketsRange(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_DEPENDENT_SIZED_ARRAY;
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
}
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitDependentSizedExtVectorType(
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
const DependentSizedExtVectorType *T) {
// FIXME: Serialize this type (C++ only)
assert(false && "Cannot serialize dependent sized extended vector types");
}
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
Record.push_back(T->getDepth());
Record.push_back(T->getIndex());
Record.push_back(T->isParameterPack());
Writer.AddIdentifierRef(T->getName(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TEMPLATE_TYPE_PARM;
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
}
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitDependentNameType(const DependentNameType *T) {
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
Record.push_back(T->getKeyword());
Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
Writer.AddIdentifierRef(T->getIdentifier(), Record);
Fix reading of DependentNameType. llvm-svn: 107474
2010-07-02 19:55:24 +08:00
Writer.AddTypeRef(T->isCanonicalUnqualified() ? QualType()
: T->getCanonicalTypeInternal(),
Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_DEPENDENT_NAME;
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
}
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitDependentTemplateSpecializationType(
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
const DependentTemplateSpecializationType *T) {
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
Record.push_back(T->getKeyword());
Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
Writer.AddIdentifierRef(T->getIdentifier(), Record);
Record.push_back(T->getNumArgs());
for (DependentTemplateSpecializationType::iterator
I = T->begin(), E = T->end(); I != E; ++I)
Writer.AddTemplateArgument(*I, Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
Record.push_back(T->getKeyword());
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
Writer.AddNestedNameSpecifier(T->getQualifier(), Record);
Writer.AddTypeRef(T->getNamedType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_ELABORATED;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Make the InjectedClassNameType the canonical type of the current instantiation of a class template or class template partial specialization. That is to say, in template <class T> class A { ... }; or template <class T> class B<const T*> { ... }; make 'A<T>' and 'B<const T*>' sugar for the corresponding InjectedClassNameType when written inside the appropriate context. This allows us to track the current instantiation appropriately even inside AST routines. It also allows us to compute a DeclContext for a type much more efficiently, at some extra cost every time we write a template specialization (which can be optimized, but I've left it simple in this patch). llvm-svn: 102407
2010-04-27 08:57:59 +08:00
Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_INJECTED_CLASS_NAME;
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_OBJC_INTERFACE;
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
Writer.AddTypeRef(T->getBaseType(), Record);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Record.push_back(T->getNumProtocols());
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
for (ObjCObjectType::qual_iterator I = T->qual_begin(),
Convert ObjC qualified type clients over to using iterators. This allows me to remove some API that I don't want to carry over to ObjCObjectPointerType. No functionality change. llvm-svn: 72475
2009-05-28 00:21:00 +08:00
E = T->qual_end(); I != E; ++I)
Writer.AddDeclRef(*I, Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_OBJC_OBJECT;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
First step toward fixing <rdar://problem/6613046> refactor clang objc type representation. Add a type (ObjCObjectPointerType) and remove a type (ObjCQualifiedIdType). This large/tedious patch is just a first step. Next step is to remove ObjCQualifiedInterfaceType. After that, I will remove the magic TypedefType for 'id' (installed by Sema). This work will enable various simplifications throughout clang (when dealing with ObjC types). No functionality change. llvm-svn: 73649
2009-06-18 06:40:22 +08:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_OBJC_OBJECT_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
namespace {
class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter &Writer;
ASTWriter::RecordData &Record;
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
public:
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
: Writer(Writer), Record(Record) { }
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
#define ABSTRACT_TYPELOC(CLASS, PARENT)
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
#define TYPELOC(CLASS, PARENT) \
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
#include "clang/AST/TypeLocNodes.def"
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void VisitArrayTypeLoc(ArrayTypeLoc TyLoc);
void VisitFunctionTypeLoc(FunctionTypeLoc TyLoc);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
};
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
// nothing to do
}
void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
Improve source-location information for builtin TypeLocs, from Enea Zaffanella (with a couple of my tweaks). llvm-svn: 93733
2010-01-19 02:04:31 +08:00
Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
if (TL.needsExtraLocalData()) {
Record.push_back(TL.getWrittenTypeSpec());
Record.push_back(TL.getWrittenSignSpec());
Record.push_back(TL.getWrittenWidthSpec());
Record.push_back(TL.hasModeAttr());
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
}
void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
Writer.AddSourceLocation(TL.getStarLoc(), Record);
}
void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
Writer.AddSourceLocation(TL.getCaretLoc(), Record);
}
void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
Writer.AddSourceLocation(TL.getAmpLoc(), Record);
}
void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
Writer.AddSourceLocation(TL.getAmpAmpLoc(), Record);
}
void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
Writer.AddSourceLocation(TL.getStarLoc(), Record);
}
void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
Writer.AddSourceLocation(TL.getLBracketLoc(), Record);
Writer.AddSourceLocation(TL.getRBracketLoc(), Record);
Record.push_back(TL.getSizeExpr() ? 1 : 0);
if (TL.getSizeExpr())
Writer.AddStmt(TL.getSizeExpr());
}
void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
DependentSizedArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
DependentSizedExtVectorTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Implement the C++0x "trailing return type" feature, e.g., auto f(int) -> int from Daniel Wallin! (With a few minor bug fixes from me). llvm-svn: 115322
2010-10-02 02:44:50 +08:00
Record.push_back(TL.getTrailingReturn());
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
Writer.AddDeclRef(TL.getArg(i), Record);
}
void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Add type source information for both kinds of typeof types. Patch by Enea Zaffanella. llvm-svn: 93344
2010-01-14 04:03:27 +08:00
Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
}
void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
Add type source information for both kinds of typeof types. Patch by Enea Zaffanella. llvm-svn: 93344
2010-01-14 04:03:27 +08:00
Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
}
void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
When performing template-substitution into a type, don't just replace the TemplateTypeParmType with the substituted type directly; instead, replace it with a SubstTemplateTypeParmType which will note that the type was originally written as a template type parameter. This makes it reasonable to preserve source information even through template substitution. Also define the new SubstTemplateTypeParmType class, obviously. For consistency with current behavior, we stringize these types as if they were the underlying type. I'm not sure this is the right thing to do. At any rate, I paled at adding yet another clause to the don't-desugar 'if' statement, so I extracted a function to do it. The new function also does The Right Thing more often, I think: e.g. if we have a chain of typedefs leading to a vector type, we will now desugar all but the last one. llvm-svn: 84412
2009-10-18 17:09:24 +08:00
void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
SubstTemplateTypeParmTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
TemplateSpecializationTypeLoc TL) {
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
Writer.AddSourceLocation(TL.getTemplateNameLoc(), Record);
Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
TL.getArgLoc(i).getLocInfo(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Added basic source locations to Elaborated and DependentName types. llvm-svn: 104169
2010-05-20 05:37:53 +08:00
Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
Writer.AddSourceRange(TL.getQualifierRange(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
Rename TypenameType to DependentNameType in anticipation of some refactoring work in this area. llvm-svn: 100019
2010-04-01 01:34:00 +08:00
void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
Added basic source locations to Elaborated and DependentName types. llvm-svn: 104169
2010-05-20 05:37:53 +08:00
Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
Writer.AddSourceRange(TL.getQualifierRange(), Record);
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
DependentTemplateSpecializationTypeLoc TL) {
Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
Writer.AddSourceRange(TL.getQualifierRange(), Record);
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
TL.getArgLoc(I).getLocInfo(), Record);
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
}
void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
Record.push_back(TL.hasBaseTypeAsWritten());
When building types from declarators, instead of building two types (one for the DeclaratorInfo, one for semantic analysis), just build a single type whose canonical type will reflect the semantic analysis (assuming the type is well-formed, of course). To make that work, make a few changes to the type system: * allow the nominal pointee type of a reference type to be a (possibly sugared) reference type. Also, preserve the original spelling of the reference type. Both of these can be ignored on canonical reference types. * Remove ObjCProtocolListType and preserve the associated source information on the various ObjC TypeLocs. Preserve the spelling of protocol lists except in the canonical form. * Preserve some level of source type structure on parameter types, but canonicalize on the canonical function type. This is still a WIP. Drops code size, makes strides towards accurate source location representation, slight (~1.7%) progression on Cocoa.h because of complexity drop. llvm-svn: 84907
2009-10-23 06:37:11 +08:00
Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
Writer.AddSourceLocation(TL.getProtocolLoc(i), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
Writer.AddSourceLocation(TL.getStarLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
//===----------------------------------------------------------------------===//
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
// ASTWriter Implementation
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
//===----------------------------------------------------------------------===//
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
static void EmitBlockID(unsigned ID, const char *Name,
llvm::BitstreamWriter &Stream,
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::RecordData &Record) {
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
Record.clear();
Record.push_back(ID);
Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
// Emit the block name if present.
if (Name == 0 || Name[0] == 0) return;
Record.clear();
while (*Name)
Record.push_back(*Name++);
Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
}
static void EmitRecordID(unsigned ID, const char *Name,
llvm::BitstreamWriter &Stream,
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::RecordData &Record) {
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
Record.clear();
Record.push_back(ID);
while (*Name)
Record.push_back(*Name++);
Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
}
static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::RecordData &Record) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
RECORD(STMT_STOP);
RECORD(STMT_NULL_PTR);
RECORD(STMT_NULL);
RECORD(STMT_COMPOUND);
RECORD(STMT_CASE);
RECORD(STMT_DEFAULT);
RECORD(STMT_LABEL);
RECORD(STMT_IF);
RECORD(STMT_SWITCH);
RECORD(STMT_WHILE);
RECORD(STMT_DO);
RECORD(STMT_FOR);
RECORD(STMT_GOTO);
RECORD(STMT_INDIRECT_GOTO);
RECORD(STMT_CONTINUE);
RECORD(STMT_BREAK);
RECORD(STMT_RETURN);
RECORD(STMT_DECL);
RECORD(STMT_ASM);
RECORD(EXPR_PREDEFINED);
RECORD(EXPR_DECL_REF);
RECORD(EXPR_INTEGER_LITERAL);
RECORD(EXPR_FLOATING_LITERAL);
RECORD(EXPR_IMAGINARY_LITERAL);
RECORD(EXPR_STRING_LITERAL);
RECORD(EXPR_CHARACTER_LITERAL);
RECORD(EXPR_PAREN);
RECORD(EXPR_UNARY_OPERATOR);
RECORD(EXPR_SIZEOF_ALIGN_OF);
RECORD(EXPR_ARRAY_SUBSCRIPT);
RECORD(EXPR_CALL);
RECORD(EXPR_MEMBER);
RECORD(EXPR_BINARY_OPERATOR);
RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
RECORD(EXPR_CONDITIONAL_OPERATOR);
RECORD(EXPR_IMPLICIT_CAST);
RECORD(EXPR_CSTYLE_CAST);
RECORD(EXPR_COMPOUND_LITERAL);
RECORD(EXPR_EXT_VECTOR_ELEMENT);
RECORD(EXPR_INIT_LIST);
RECORD(EXPR_DESIGNATED_INIT);
RECORD(EXPR_IMPLICIT_VALUE_INIT);
RECORD(EXPR_VA_ARG);
RECORD(EXPR_ADDR_LABEL);
RECORD(EXPR_STMT);
RECORD(EXPR_TYPES_COMPATIBLE);
RECORD(EXPR_CHOOSE);
RECORD(EXPR_GNU_NULL);
RECORD(EXPR_SHUFFLE_VECTOR);
RECORD(EXPR_BLOCK);
RECORD(EXPR_BLOCK_DECL_REF);
RECORD(EXPR_OBJC_STRING_LITERAL);
RECORD(EXPR_OBJC_ENCODE);
RECORD(EXPR_OBJC_SELECTOR_EXPR);
RECORD(EXPR_OBJC_PROTOCOL_EXPR);
RECORD(EXPR_OBJC_IVAR_REF_EXPR);
RECORD(EXPR_OBJC_PROPERTY_REF_EXPR);
RECORD(EXPR_OBJC_KVC_REF_EXPR);
RECORD(EXPR_OBJC_MESSAGE_EXPR);
RECORD(STMT_OBJC_FOR_COLLECTION);
RECORD(STMT_OBJC_CATCH);
RECORD(STMT_OBJC_FINALLY);
RECORD(STMT_OBJC_AT_TRY);
RECORD(STMT_OBJC_AT_SYNCHRONIZED);
RECORD(STMT_OBJC_AT_THROW);
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
RECORD(EXPR_CXX_OPERATOR_CALL);
RECORD(EXPR_CXX_CONSTRUCT);
RECORD(EXPR_CXX_STATIC_CAST);
RECORD(EXPR_CXX_DYNAMIC_CAST);
RECORD(EXPR_CXX_REINTERPRET_CAST);
RECORD(EXPR_CXX_CONST_CAST);
RECORD(EXPR_CXX_FUNCTIONAL_CAST);
RECORD(EXPR_CXX_BOOL_LITERAL);
RECORD(EXPR_CXX_NULL_PTR_LITERAL);
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
#undef RECORD
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteBlockInfoBlock() {
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RecordData Record;
Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
#define BLOCK(X) EmitBlockID(X ## _ID, #X, Stream, Record)
#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// AST Top-Level Block.
Rename stuff in PCHBitCodes.h llvm-svn: 111475
2010-08-19 07:57:22 +08:00
BLOCK(AST_BLOCK);
emit ORIGINAL_FILE_NAME record ID to blockinfo block. llvm-svn: 72759
2009-06-03 17:23:28 +08:00
RECORD(ORIGINAL_FILE_NAME);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(TYPE_OFFSET);
RECORD(DECL_OFFSET);
RECORD(LANGUAGE_OPTIONS);
Add a header containing the Clang version; make the driver use this Clang version value rather than hard-coding "1.0". Add PCH and Clang version information into the PCH file. Reject PCH files with the wrong version information. llvm-svn: 70264
2009-04-28 06:23:34 +08:00
RECORD(METADATA);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(IDENTIFIER_OFFSET);
RECORD(IDENTIFIER_TABLE);
RECORD(EXTERNAL_DEFINITIONS);
RECORD(SPECIAL_TYPES);
RECORD(STATISTICS);
RECORD(TENTATIVE_DEFINITIONS);
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
RECORD(UNUSED_FILESCOPED_DECLS);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS);
RECORD(SELECTOR_OFFSETS);
RECORD(METHOD_POOL);
RECORD(PP_COUNTER_VALUE);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
RECORD(SOURCE_LOCATION_OFFSETS);
RECORD(SOURCE_LOCATION_PRELOADS);
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
RECORD(STAT_CACHE);
Add Sema::ExtVectorDecls and Sema::ObjCCategoryImpls to the PCH file. Since these vectors are very, very rarely used and, when used in headers, and even when used are relatively small, we load them eagerly. llvm-svn: 70240
2009-04-28 04:06:05 +08:00
RECORD(EXT_VECTOR_DECLS);
Rename pch::SVN_BRANCH_REVISION to pch::VERSION_CONTROL_BRANCH_REVISION. llvm-svn: 94214
2010-01-23 04:59:36 +08:00
RECORD(VERSION_CONTROL_BRANCH_REVISION);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
RECORD(MACRO_DEFINITION_OFFSETS);
Some preparatory work for chained PCH. No functionality change. llvm-svn: 107915
2010-07-09 06:01:51 +08:00
RECORD(CHAINED_METADATA);
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
RECORD(REFERENCED_SELECTOR_POOL);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
// SourceManager Block.
drop the _ID suffixes from block names. llvm-svn: 70169
2009-04-27 08:40:25 +08:00
BLOCK(SOURCE_MANAGER_BLOCK);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(SM_SLOC_FILE_ENTRY);
RECORD(SM_SLOC_BUFFER_ENTRY);
RECORD(SM_SLOC_BUFFER_BLOB);
RECORD(SM_SLOC_INSTANTIATION_ENTRY);
RECORD(SM_LINE_TABLE);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
// Preprocessor Block.
drop the _ID suffixes from block names. llvm-svn: 70169
2009-04-27 08:40:25 +08:00
BLOCK(PREPROCESSOR_BLOCK);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(PP_MACRO_OBJECT_LIKE);
RECORD(PP_MACRO_FUNCTION_LIKE);
RECORD(PP_TOKEN);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
RECORD(PP_MACRO_INSTANTIATION);
RECORD(PP_MACRO_DEFINITION);
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
// Decls and Types block.
BLOCK(DECLTYPES_BLOCK);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(TYPE_EXT_QUAL);
RECORD(TYPE_COMPLEX);
RECORD(TYPE_POINTER);
RECORD(TYPE_BLOCK_POINTER);
RECORD(TYPE_LVALUE_REFERENCE);
RECORD(TYPE_RVALUE_REFERENCE);
RECORD(TYPE_MEMBER_POINTER);
RECORD(TYPE_CONSTANT_ARRAY);
RECORD(TYPE_INCOMPLETE_ARRAY);
RECORD(TYPE_VARIABLE_ARRAY);
RECORD(TYPE_VECTOR);
RECORD(TYPE_EXT_VECTOR);
RECORD(TYPE_FUNCTION_PROTO);
RECORD(TYPE_FUNCTION_NO_PROTO);
RECORD(TYPE_TYPEDEF);
RECORD(TYPE_TYPEOF_EXPR);
RECORD(TYPE_TYPEOF);
RECORD(TYPE_RECORD);
RECORD(TYPE_ENUM);
RECORD(TYPE_OBJC_INTERFACE);
Emit a type record for TYPE_OBJC_OBJECT in the PCH file. I'm not entirely sure what this does, to be honest. llvm-svn: 103895
2010-05-16 10:12:35 +08:00
RECORD(TYPE_OBJC_OBJECT);
First step toward fixing <rdar://problem/6613046> refactor clang objc type representation. Add a type (ObjCObjectPointerType) and remove a type (ObjCQualifiedIdType). This large/tedious patch is just a first step. Next step is to remove ObjCQualifiedInterfaceType. After that, I will remove the magic TypedefType for 'id' (installed by Sema). This work will enable various simplifications throughout clang (when dealing with ObjC types). No functionality change. llvm-svn: 73649
2009-06-18 06:40:22 +08:00
RECORD(TYPE_OBJC_OBJECT_POINTER);
add the decl names. llvm-svn: 70167
2009-04-27 06:32:16 +08:00
RECORD(DECL_ATTR);
RECORD(DECL_TRANSLATION_UNIT);
RECORD(DECL_TYPEDEF);
RECORD(DECL_ENUM);
RECORD(DECL_RECORD);
RECORD(DECL_ENUM_CONSTANT);
RECORD(DECL_FUNCTION);
RECORD(DECL_OBJC_METHOD);
RECORD(DECL_OBJC_INTERFACE);
RECORD(DECL_OBJC_PROTOCOL);
RECORD(DECL_OBJC_IVAR);
RECORD(DECL_OBJC_AT_DEFS_FIELD);
RECORD(DECL_OBJC_CLASS);
RECORD(DECL_OBJC_FORWARD_PROTOCOL);
RECORD(DECL_OBJC_CATEGORY);
RECORD(DECL_OBJC_CATEGORY_IMPL);
RECORD(DECL_OBJC_IMPLEMENTATION);
RECORD(DECL_OBJC_COMPATIBLE_ALIAS);
RECORD(DECL_OBJC_PROPERTY);
RECORD(DECL_OBJC_PROPERTY_IMPL);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(DECL_FIELD);
RECORD(DECL_VAR);
add the decl names. llvm-svn: 70167
2009-04-27 06:32:16 +08:00
RECORD(DECL_IMPLICIT_PARAM);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(DECL_PARM_VAR);
add the decl names. llvm-svn: 70167
2009-04-27 06:32:16 +08:00
RECORD(DECL_FILE_SCOPE_ASM);
RECORD(DECL_BLOCK);
RECORD(DECL_CONTEXT_LEXICAL);
RECORD(DECL_CONTEXT_VISIBLE);
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
// Statements and Exprs can occur in the Decls and Types block.
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
AddStmtsExprs(Stream, Record);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
#undef RECORD
#undef BLOCK
Stream.ExitBlock();
}
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
/// \brief Adjusts the given filename to only write out the portion of the
/// filename that is not part of the system root directory.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
///
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
/// \param Filename the file name to adjust.
///
/// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and
/// the returned filename will be adjusted by this system root.
///
/// \returns either the original filename (if it needs no adjustment) or the
/// adjusted filename (which points into the @p Filename parameter).
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
static const char *
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
adjustFilenameForRelocatablePCH(const char *Filename, const char *isysroot) {
assert(Filename && "No file name to adjust?");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
if (!isysroot)
return Filename;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// Verify that the filename and the system root have the same prefix.
unsigned Pos = 0;
for (; Filename[Pos] && isysroot[Pos]; ++Pos)
if (Filename[Pos] != isysroot[Pos])
return Filename; // Prefixes don't match.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// We hit the end of the filename before we hit the end of the system root.
if (!Filename[Pos])
return Filename;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// If the file name has a '/' at the current position, skip over the '/'.
// We distinguish sysroot-based includes from absolute includes by the
// absence of '/' at the beginning of sysroot-based includes.
if (Filename[Pos] == '/')
++Pos;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
return Filename + Pos;
}
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the AST metadata (e.g., i686-apple-darwin9).
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteMetadata(ASTContext &Context, const char *isysroot) {
Encode the target triple in the PCH file, and check that target triple when using the PCH file llvm-svn: 68824
2009-04-11 05:16:55 +08:00
using namespace llvm;
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// Metadata
const TargetInfo &Target = Context.Target;
BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev();
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
MetaAbbrev->Add(BitCodeAbbrevOp(
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Chain ? CHAINED_METADATA : METADATA));
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
// Target triple or chained PCH name
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(Chain ? CHAINED_METADATA : METADATA);
Record.push_back(VERSION_MAJOR);
Record.push_back(VERSION_MINOR);
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Record.push_back(CLANG_VERSION_MAJOR);
Record.push_back(CLANG_VERSION_MINOR);
Record.push_back(isysroot != 0);
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
// FIXME: This writes the absolute path for chained headers.
const std::string &BlobStr = Chain ? Chain->getFileName() : Target.getTriple().getTriple();
Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, BlobStr);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
// Original file name
SourceManager &SM = Context.getSourceManager();
if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME));
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev);
llvm::sys::Path MainFilePath(MainFile->getName());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
MainFilePath.makeAbsolute();
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
Path related cleanup. Remove unnecessary variables. llvm-svn: 98473
2010-03-14 15:15:57 +08:00
const char *MainFileNameStr = MainFilePath.c_str();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr,
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
isysroot);
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(ORIGINAL_FILE_NAME);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr);
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
}
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
(1) Rename getClangSubversionRevision() to getClangRevision(), and have it return a StringRef instead of an integer (to be more VCS agnostic). (2) Add getClangFullRepositoryVersion(), which contains an amalgamation of the repository name and the revision. (3) Change PCH to only emit the string returned by getClangFullRepositoryVersion() instead of also emitting the value of getClangSubversionRevision() (which has been removed). This is functionally equivalent. More cleanup to version string generation pending... llvm-svn: 94231
2010-01-23 06:12:47 +08:00
// Repository branch/version information.
BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION));
(1) Rename getClangSubversionRevision() to getClangRevision(), and have it return a StringRef instead of an integer (to be more VCS agnostic). (2) Add getClangFullRepositoryVersion(), which contains an amalgamation of the repository name and the revision. (3) Change PCH to only emit the string returned by getClangFullRepositoryVersion() instead of also emitting the value of getClangSubversionRevision() (which has been removed). This is functionally equivalent. More cleanup to version string generation pending... llvm-svn: 94231
2010-01-23 06:12:47 +08:00
RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev);
Encode the Clang branch and Subversion revision into a PCH file, and assume that PCH files from different Clang revisions are not compatible. Addresses <rdar://problem/7266572>. llvm-svn: 83323
2009-10-06 05:07:28 +08:00
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(VERSION_CONTROL_BRANCH_REVISION);
(1) Rename getClangSubversionRevision() to getClangRevision(), and have it return a StringRef instead of an integer (to be more VCS agnostic). (2) Add getClangFullRepositoryVersion(), which contains an amalgamation of the repository name and the revision. (3) Change PCH to only emit the string returned by getClangFullRepositoryVersion() instead of also emitting the value of getClangSubversionRevision() (which has been removed). This is functionally equivalent. More cleanup to version string generation pending... llvm-svn: 94231
2010-01-23 06:12:47 +08:00
Stream.EmitRecordWithBlob(RepoAbbrevCode, Record,
getClangFullRepositoryVersion());
Encode the target triple in the PCH file, and check that target triple when using the PCH file llvm-svn: 68824
2009-04-11 05:16:55 +08:00
}
/// \brief Write the LangOptions structure.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
RecordData Record;
Record.push_back(LangOpts.Trigraphs);
Record.push_back(LangOpts.BCPLComment); // BCPL-style '//' comments.
Record.push_back(LangOpts.DollarIdents); // '$' allowed in identifiers.
Record.push_back(LangOpts.AsmPreprocessor); // Preprocessor in asm mode.
Record.push_back(LangOpts.GNUMode); // True in gnu99 mode false in c99 mode (etc)
Add support for '-fgnu-keywords' and '-fasm' to Clang's driver. They are not implemented precisely the same as GCC, but the distinction GCC makes isn't useful to represent. This allows parsing code which uses GCC-specific keywords ('asm', etc.) without parsing in a fully GNU mode. llvm-svn: 101667
2010-04-18 04:17:31 +08:00
Record.push_back(LangOpts.GNUKeywords); // Allow GNU-extension keywords
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.ImplicitInt); // C89 implicit 'int'.
Record.push_back(LangOpts.Digraphs); // C94, C99 and C++
Record.push_back(LangOpts.HexFloats); // C99 Hexadecimal float constants.
Record.push_back(LangOpts.C99); // C99 Support
Record.push_back(LangOpts.Microsoft); // Microsoft extensions.
Record.push_back(LangOpts.CPlusPlus); // C++ Support
Record.push_back(LangOpts.CPlusPlus0x); // C++0x Support
Record.push_back(LangOpts.CXXOperatorNames); // Treat C++ operator names as keywords.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.ObjC1); // Objective-C 1 support enabled.
Record.push_back(LangOpts.ObjC2); // Objective-C 2 support enabled.
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Record.push_back(LangOpts.ObjCNonFragileABI); // Objective-C
Implement synthesizing properties by default. This is a non-fragile-abi feature only. Since it breaks existing code, it is currently placed under -fobjc-nonfragile-abi2 option for test purposes only until further notice. WIP. llvm-svn: 95685
2010-02-10 03:31:38 +08:00
// modern abi enabled.
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Record.push_back(LangOpts.ObjCNonFragileABI2); // Objective-C enhanced
Implement synthesizing properties by default. This is a non-fragile-abi feature only. Since it breaks existing code, it is currently placed under -fobjc-nonfragile-abi2 option for test purposes only until further notice. WIP. llvm-svn: 95685
2010-02-10 03:31:38 +08:00
// modern abi enabled.
Check for -fno-constant-cfstrings consistency in pch. llvm-svn: 102130
2010-04-23 05:01:59 +08:00
Record.push_back(LangOpts.NoConstantCFStrings); // non cfstring generation enabled..
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.PascalStrings); // Allow Pascal strings
Record.push_back(LangOpts.WritableStrings); // Allow writable strings
Record.push_back(LangOpts.LaxVectorConversions);
Write/Read new Language Options llvm-svn: 74221
2009-06-26 07:01:11 +08:00
Record.push_back(LangOpts.AltiVec);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Exceptions); // Support exception handling.
clang -cc1: Add -fsjlj-exceptions, which requires far too much button pushing. llvm-svn: 95785
2010-02-11 02:48:44 +08:00
Record.push_back(LangOpts.SjLjExceptions);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.NeXTRuntime); // Use NeXT runtime.
Record.push_back(LangOpts.Freestanding); // Freestanding implementation
Record.push_back(LangOpts.NoBuiltin); // Do not use builtin functions (-fno-builtin)
add an abbreviation for common PARM_VAR_DECL. All but 9 of the parm var decls in leopard cocoa.h end up using this abbreviation, which shrinks the bitcode file by about 50K: 7217736->7167120. Before: Block ID #12 (DECLS_BLOCK): Num Instances: 1 Total Size: 2.23595e+07b/2.79494e+06B/698736W % of file: 38.7233 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 139387 % Abbrev Recs: 0 After: Block ID #12 (DECLS_BLOCK): Num Instances: 1 Total Size: 2.02405e+07b/2.53006e+06B/632516W % of file: 35.301 Num SubBlocks: 0 Num Abbrevs: 1 Num Records: 139387 % Abbrev Recs: 19.2902 llvm-svn: 70199
2009-04-27 15:35:58 +08:00
// Whether static initializers are protected by locks.
Record.push_back(LangOpts.ThreadsafeStatics);
Save/load POSIXThreads flag for PCH llvm-svn: 80916
2009-09-03 22:36:33 +08:00
Record.push_back(LangOpts.POSIXThreads);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Blocks); // block extension to C
Record.push_back(LangOpts.EmitAllDecls); // Emit all declarations, even if
// they are unused.
Record.push_back(LangOpts.MathErrno); // Math functions must respect errno
// (modulo the platform support).
Implement support for -fwrapv, rdar://7221421 As part of this, pull together trapv handling into the same enum. This also add support for NSW multiplies. This also makes PCH disagreement on overflow behavior silent, since it really doesn't matter except for warnings and codegen (no macros get defined etc). llvm-svn: 106956
2010-06-27 05:25:03 +08:00
Record.push_back(LangOpts.getSignedOverflowBehavior());
Record.push_back(LangOpts.HeinousExtensions);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Optimize); // Whether __OPTIMIZE__ should be defined.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Record.push_back(LangOpts.OptimizeSize); // Whether __OPTIMIZE_SIZE__ should be
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
// defined.
Record.push_back(LangOpts.Static); // Should __STATIC__ be defined (as
// opposed to __DYNAMIC__).
Record.push_back(LangOpts.PICLevel); // The value for __PIC__, if non-zero.
Record.push_back(LangOpts.GNUInline); // Should GNU inline semantics be
// used (instead of C99 semantics).
Record.push_back(LangOpts.NoInline); // Should __NO_INLINE__ be defined.
Disable access control by default. It can be enabled with the -faccess-control option. When we have better support for it, we can enable it by default again. llvm-svn: 71706
2009-05-14 03:49:53 +08:00
Record.push_back(LangOpts.AccessControl); // Whether C++ access control should
// be enabled.
Move CharIsSigned from TargetInfo to LangOptions. llvm-svn: 72928
2009-06-05 15:05:05 +08:00
Record.push_back(LangOpts.CharIsSigned); // Whether char is a signed or
// unsigned type
Adding -fshort-wchar option. llvm-svn: 86167
2009-11-06 04:14:16 +08:00
Record.push_back(LangOpts.ShortWChar); // force wchar_t to be unsigned short
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.getGCMode());
Record.push_back(LangOpts.getVisibilityMode());
Add missing PCH support for -fstack-protector. llvm-svn: 82435
2009-09-21 12:16:19 +08:00
Record.push_back(LangOpts.getStackProtectorMode());
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.InstantiationDepth);
Write/Read new Language Options llvm-svn: 74221
2009-06-26 07:01:11 +08:00
Record.push_back(LangOpts.OpenCL);
Implement runtime checks for undefined behavior. WIP. This implements a new flag -fcatch-undefined-behavior. The flag turns on additional runtime checks for: T a[I]; a[i] abort when i < 0 or i >= I. Future stuff includes shifts by >= bitwidth amounts. llvm-svn: 91198
2009-12-12 09:27:46 +08:00
Record.push_back(LangOpts.CatchUndefined);
Add a -fno-elide-constructors option to clang-cc. llvm-svn: 79782
2009-08-23 06:30:33 +08:00
Record.push_back(LangOpts.ElideConstructors);
Introduce -f{no-}spell-checking options to enable/disable spell-checking. By default, spell-checking is enabled for Clang (obviously) but disabled in CIndex for performance reasons. llvm-svn: 107992
2010-07-10 01:35:33 +08:00
Record.push_back(LangOpts.SpellChecking);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// stat cache Serialization
//===----------------------------------------------------------------------===//
namespace {
// Trait used for the on-disk hash table of stat cache results.
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
class ASTStatCacheTrait {
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
public:
typedef const char * key_type;
typedef key_type key_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
typedef std::pair<int, struct stat> data_type;
typedef const data_type& data_type_ref;
static unsigned ComputeHash(const char *path) {
Switch to llvm::HashString. llvm-svn: 84375
2009-10-18 07:52:28 +08:00
return llvm::HashString(path);
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<unsigned,unsigned>
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
EmitKeyDataLength(llvm::raw_ostream& Out, const char *path,
data_type_ref Data) {
unsigned StrLen = strlen(path);
clang::io::Emit16(Out, StrLen);
unsigned DataLen = 1; // result value
if (Data.first == 0)
DataLen += 4 + 4 + 2 + 8 + 8;
clang::io::Emit8(Out, DataLen);
return std::make_pair(StrLen + 1, DataLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
void EmitKey(llvm::raw_ostream& Out, const char *path, unsigned KeyLen) {
Out.write(path, KeyLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
void EmitData(llvm::raw_ostream& Out, key_type_ref,
data_type_ref Data, unsigned DataLen) {
using namespace clang::io;
uint64_t Start = Out.tell(); (void)Start;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
// Result of stat()
Emit8(Out, Data.first? 1 : 0);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
if (Data.first == 0) {
Emit32(Out, (uint32_t) Data.second.st_ino);
Emit32(Out, (uint32_t) Data.second.st_dev);
Emit16(Out, (uint16_t) Data.second.st_mode);
Emit64(Out, (uint64_t) Data.second.st_mtime);
Emit64(Out, (uint64_t) Data.second.st_size);
}
assert(Out.tell() - Start == DataLen && "Wrong data length");
}
};
} // end anonymous namespace
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the stat() system call cache to the AST file.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) {
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
// Build the on-disk hash table containing information about every
// stat() call.
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator;
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
unsigned NumStatEntries = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (MemorizeStatCalls::iterator Stat = StatCalls.begin(),
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
StatEnd = StatCalls.end();
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Stat != StatEnd; ++Stat, ++NumStatEntries) {
const char *Filename = Stat->first();
Generator.insert(Filename, Stat->second);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
// Create the on-disk hash table in a buffer.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallString<4096> StatCacheData;
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(StatCacheData);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out);
}
// Create a blob abbreviation
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE));
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev);
// Write the stat cache
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(STAT_CACHE);
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
Record.push_back(BucketOffset);
Record.push_back(NumStatEntries);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str());
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
}
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
//===----------------------------------------------------------------------===//
// Source Manager Serialization
//===----------------------------------------------------------------------===//
/// \brief Create an abbreviation for the SLocEntry that refers to a
/// file.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
Keep track of the size/modification time of each file source-location entry in a precompiled header, so that we can detect modified files even when we miss in the stat cache. llvm-svn: 99149
2010-03-22 06:49:54 +08:00
// FileEntry fields.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
Fix header-search problems with precompiled headers, where the presence or absence of header map arguments when using the precompiled header would cause Clang to get confused about which headers had already been included/imported, along with their controlling macros. The fundamental problem is that the serialization of the header search information was relying on the UIDs of FileEntry objects at PCH generation time and PCH load time to be equivalent, which effectively means that we had to probe the same files in the same order. Differing header map arguments caused an extra FileEntry lookup, but it's easy to imagine other minor command-line arguments triggering this problem. Header-search information is now encoded along with the source-location entry for a file, so that we register information about a file's properties as a header at the same time we create the FileEntry for that file. Fixes <rdar://problem/7743243>. llvm-svn: 98636
2010-03-17 00:35:32 +08:00
// HeaderFileInfo fields.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isImport
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // DirInfo
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumIncludes
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // ControllingMacro
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
/// \brief Create an abbreviation for the SLocEntry that refers to a
/// buffer.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
/// \brief Create an abbreviation for the SLocEntry that refers to a
/// buffer's blob.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
/// \brief Create an abbreviation for the SLocEntry that refers to an
/// buffer.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_INSTANTIATION_ENTRY));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Spelling location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
For source location entries that describe instantiations, encode the token length in the PCH file rather than trying (and failing) to reconstruct it be getting the spelling token's length. llvm-svn: 69191
2009-04-16 02:05:10 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
/// \brief Writes the block containing the serialized form of the
/// source manager.
///
/// TODO: We should probably use an on-disk hash table (stored in a
/// blob), indexed based on the file name, so that we only create
/// entries for files that we actually need. In the common case (no
/// errors), we probably won't have to create file entries for any of
/// the files in the AST.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
const Preprocessor &PP,
const char *isysroot) {
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
RecordData Record;
improve punctuation llvm-svn: 68791
2009-04-11 01:16:57 +08:00
// Enter the source manager block.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EnterSubblock(SOURCE_MANAGER_BLOCK_ID, 3);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
// Abbreviations for the various kinds of source-location entries.
make these be unsigned now that they are eagerly created. llvm-svn: 70229
2009-04-28 03:03:22 +08:00
unsigned SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
unsigned SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
unsigned SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream);
unsigned SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(Stream);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// Write the line table.
if (SourceMgr.hasLineTable()) {
LineTableInfo &LineTable = SourceMgr.getLineTable();
// Emit the file names
Record.push_back(LineTable.getNumFilenames());
for (unsigned I = 0, N = LineTable.getNumFilenames(); I != N; ++I) {
// Emit the file name
const char *Filename = LineTable.getFilename(I);
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
unsigned FilenameLen = Filename? strlen(Filename) : 0;
Record.push_back(FilenameLen);
if (FilenameLen)
Record.insert(Record.end(), Filename, Filename + FilenameLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// Emit the line entries
for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end();
L != LEnd; ++L) {
// Emit the file ID
Record.push_back(L->first);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// Emit the line entries
Record.push_back(L->second.size());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (std::vector<LineEntry>::iterator LE = L->second.begin(),
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
LEEnd = L->second.end();
LE != LEEnd; ++LE) {
Record.push_back(LE->FileOffset);
Record.push_back(LE->LineNo);
Record.push_back(LE->FilenameID);
Record.push_back((unsigned)LE->FileKind);
Record.push_back(LE->IncludeOffset);
}
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(SM_LINE_TABLE, Record);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
}
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
// Write out the source location entry table. We skip the first
// entry, which is always the same dummy entry.
shrink SOURCE_LOCATION_OFFSETS to use 4-byte entries instead of 8-byte entries, shaving 100K off the PCH file for cocoa. llvm-svn: 70228
2009-04-28 03:01:47 +08:00
std::vector<uint32_t> SLocEntryOffsets;
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
RecordData PreloadSLocs;
Allow loading declcontext information from any file in the chain. Properly write source locations to dependent files. WIP llvm-svn: 109119
2010-07-23 01:01:13 +08:00
unsigned BaseSLocID = Chain ? Chain->getTotalNumSLocs() : 0;
SLocEntryOffsets.reserve(SourceMgr.sloc_entry_size() - 1 - BaseSLocID);
for (unsigned I = BaseSLocID + 1, N = SourceMgr.sloc_entry_size();
I != N; ++I) {
While writing source-location entries to a PCH file, go through an interface that can load those source-location entries on demand (from another PCH file). llvm-svn: 84287
2009-10-17 06:46:09 +08:00
// Get this source location entry.
const SrcMgr::SLocEntry *SLoc = &SourceMgr.getSLocEntry(I);
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// Record the offset of this source-location entry.
SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
// Figure out which record code to use.
unsigned Code;
if (SLoc->isFile()) {
if (SLoc->getFile().getContentCache()->Entry)
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = SM_SLOC_FILE_ENTRY;
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
else
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = SM_SLOC_BUFFER_ENTRY;
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
} else
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = SM_SLOC_INSTANTIATION_ENTRY;
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Record.clear();
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Record.push_back(Code);
Record.push_back(SLoc->getOffset());
if (SLoc->isFile()) {
const SrcMgr::FileInfo &File = SLoc->getFile();
Record.push_back(File.getIncludeLoc().getRawEncoding());
Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
Include the SourceManager's line table in the PCH file. We can now properly cope with #line directives in PCH files. llvm-svn: 68963
2009-04-14 00:31:14 +08:00
Record.push_back(File.hasLineDirectives());
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
const SrcMgr::ContentCache *Content = File.getContentCache();
if (Content->Entry) {
// The source location entry is a file. The blob associated
// with this entry is the file name.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Keep track of the size/modification time of each file source-location entry in a precompiled header, so that we can detect modified files even when we miss in the stat cache. llvm-svn: 99149
2010-03-22 06:49:54 +08:00
// Emit size/modification time for this file.
Record.push_back(Content->Entry->getSize());
Record.push_back(Content->Entry->getModificationTime());
Fix header-search problems with precompiled headers, where the presence or absence of header map arguments when using the precompiled header would cause Clang to get confused about which headers had already been included/imported, along with their controlling macros. The fundamental problem is that the serialization of the header search information was relying on the UIDs of FileEntry objects at PCH generation time and PCH load time to be equivalent, which effectively means that we had to probe the same files in the same order. Differing header map arguments caused an extra FileEntry lookup, but it's easy to imagine other minor command-line arguments triggering this problem. Header-search information is now encoded along with the source-location entry for a file, so that we register information about a file's properties as a header at the same time we create the FileEntry for that file. Fixes <rdar://problem/7743243>. llvm-svn: 98636
2010-03-17 00:35:32 +08:00
// Emit header-search information associated with this file.
HeaderFileInfo HFI;
HeaderSearch &HS = PP.getHeaderSearchInfo();
if (Content->Entry->getUID() < HS.header_file_size())
HFI = HS.header_file_begin()[Content->Entry->getUID()];
Record.push_back(HFI.isImport);
Record.push_back(HFI.DirInfo);
Record.push_back(HFI.NumIncludes);
AddIdentifierRef(HFI.ControllingMacro, Record);
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// Turn the file name into an absolute path, if it isn't already.
const char *Filename = Content->Entry->getName();
llvm::sys::Path FilePath(Filename, strlen(Filename));
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
FilePath.makeAbsolute();
Path related cleanup. Remove unnecessary variables. llvm-svn: 98473
2010-03-14 15:15:57 +08:00
Filename = FilePath.c_str();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// FIXME: For now, preload all file source locations, so that
// we get the appropriate File entries in the reader. This is
// a temporary measure.
Allow loading declcontext information from any file in the chain. Properly write source locations to dependent files. WIP llvm-svn: 109119
2010-07-23 01:01:13 +08:00
PreloadSLocs.push_back(BaseSLocID + SLocEntryOffsets.size());
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
} else {
// The source location entry is a buffer. The blob associated
// with this entry contains the contents of the buffer.
// We add one to the size so that we capture the trailing NULL
// that is required by llvm::MemoryBuffer::getMemBuffer (on
// the reader side).
Use SourceManager's Diagnostic object for all file-reading errors, simplifying the SourceManager interfaces somewhat. llvm-svn: 98598
2010-03-16 08:35:39 +08:00
const llvm::MemoryBuffer *Buffer
push some source location information down through the compiler, into ContentCache::getBuffer. This allows it to produce diagnostics on the broken #include line instead of without a location. llvm-svn: 101939
2010-04-21 04:35:58 +08:00
= Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
const char *Name = Buffer->getBufferIdentifier();
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record,
llvm::StringRef(Name, strlen(Name) + 1));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(SM_SLOC_BUFFER_BLOB);
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
llvm::StringRef(Buffer->getBufferStart(),
Buffer->getBufferSize() + 1));
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
if (strcmp(Name, "<built-in>") == 0)
Allow loading declcontext information from any file in the chain. Properly write source locations to dependent files. WIP llvm-svn: 109119
2010-07-23 01:01:13 +08:00
PreloadSLocs.push_back(BaseSLocID + SLocEntryOffsets.size());
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
} else {
// The source location entry is an instantiation.
const SrcMgr::InstantiationInfo &Inst = SLoc->getInstantiation();
Record.push_back(Inst.getSpellingLoc().getRawEncoding());
Record.push_back(Inst.getInstantiationLocStart().getRawEncoding());
Record.push_back(Inst.getInstantiationLocEnd().getRawEncoding());
For source location entries that describe instantiations, encode the token length in the PCH file rather than trying (and failing) to reconstruct it be getting the spelling token's length. llvm-svn: 69191
2009-04-16 02:05:10 +08:00
// Compute the token length for this macro expansion.
unsigned NextOffset = SourceMgr.getNextOffset();
While writing source-location entries to a PCH file, go through an interface that can load those source-location entries on demand (from another PCH file). llvm-svn: 84287
2009-10-17 06:46:09 +08:00
if (I + 1 != N)
NextOffset = SourceMgr.getSLocEntry(I + 1).getOffset();
For source location entries that describe instantiations, encode the token length in the PCH file rather than trying (and failing) to reconstruct it be getting the spelling token's length. llvm-svn: 69191
2009-04-16 02:05:10 +08:00
Record.push_back(NextOffset - SLoc->getOffset() - 1);
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
}
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Stream.ExitBlock();
Include the SourceManager's line table in the PCH file. We can now properly cope with #line directives in PCH files. llvm-svn: 68963
2009-04-14 00:31:14 +08:00
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
if (SLocEntryOffsets.empty())
return;
Don't read all of the records in the PCH file's preprocessor block, most of which are ignored. Instead, move the __COUNTER__ value out to a PCH-level record (since it is handled eagerly) and move the header file information into the SourceManager block (which is also, currently, loaded eagerly). This results in another 17% performance improvement in the Cocoa-prefixed "Hello, World" with PCH. llvm-svn: 70097
2009-04-26 08:07:37 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Write the source-location offsets table into the AST block. This
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// table is used for lazily loading source-location information.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SOURCE_LOCATION_OFFSETS));
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // next offset
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(SOURCE_LOCATION_OFFSETS);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Record.push_back(SLocEntryOffsets.size());
Change source manager serialization to be less tied to the PCH model. llvm-svn: 114575
2010-09-23 04:19:08 +08:00
unsigned BaseOffset = Chain ? Chain->getNextSLocOffset() : 0;
Record.push_back(SourceMgr.getNextOffset() - BaseOffset);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record,
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
(const char *)data(SLocEntryOffsets),
shrink SOURCE_LOCATION_OFFSETS to use 4-byte entries instead of 8-byte entries, shaving 100K off the PCH file for cocoa. llvm-svn: 70228
2009-04-28 03:01:47 +08:00
SLocEntryOffsets.size()*sizeof(SLocEntryOffsets[0]));
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Write the source location entry preloads array, telling the AST
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
// reader which source locations entries it should load eagerly.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(SOURCE_LOCATION_PRELOADS, PreloadSLocs);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// Preprocessor Serialization
//===----------------------------------------------------------------------===//
Arrange for the preprocessor to be passed down into the PCH writer. llvm-svn: 68790
2009-04-11 01:15:23 +08:00
/// \brief Writes the block containing the serialized form of the
/// preprocessor.
///
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WritePreprocessor(const Preprocessor &PP) {
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
RecordData Record;
implement the microsoft/gnu "__COUNTER__" macro: rdar://4329310 llvm-svn: 68933
2009-04-13 09:29:17 +08:00
// If the preprocessor __COUNTER__ value has been bumped, remember it.
if (PP.getCounterValue() != 0) {
Record.push_back(PP.getCounterValue());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(PP_COUNTER_VALUE, Record);
implement the microsoft/gnu "__COUNTER__" macro: rdar://4329310 llvm-svn: 68933
2009-04-13 09:29:17 +08:00
Record.clear();
Don't read all of the records in the PCH file's preprocessor block, most of which are ignored. Instead, move the __COUNTER__ value out to a PCH-level record (since it is handled eagerly) and move the header file information into the SourceManager block (which is also, currently, loaded eagerly). This results in another 17% performance improvement in the Cocoa-prefixed "Hello, World" with PCH. llvm-svn: 70097
2009-04-26 08:07:37 +08:00
}
// Enter the preprocessor block.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 2);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// If the AST file contains __DATE__ or __TIME__ emit a warning about this.
Don't read all of the records in the PCH file's preprocessor block, most of which are ignored. Instead, move the __COUNTER__ value out to a PCH-level record (since it is handled eagerly) and move the header file information into the SourceManager block (which is also, currently, loaded eagerly). This results in another 17% performance improvement in the Cocoa-prefixed "Hello, World" with PCH. llvm-svn: 70097
2009-04-26 08:07:37 +08:00
// FIXME: use diagnostics subsystem for localization etc.
if (PP.SawDateOrTime())
fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
// Loop over all the macro definitions that are live at the end of the file,
// emitting each to the PP section.
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end();
I != E; ++I) {
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
// FIXME: This emits macros in hash table order, we should do it in a stable
// order so that output is reproducible.
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
MacroInfo *MI = I->second;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Don't emit builtin macros like __LINE__ to the AST file unless they have
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
// been redefined by the header (in which case they are not isBuiltinMacro).
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Also skip macros from a AST file if we're chaining.
When an identifier that has a macro definition in the original PCH file is somehow changed in a chained PCH file, make sure that we write out the macro definition. Fixes part of <rdar://problem/8499034>. llvm-svn: 115259
2010-10-01 09:03:07 +08:00
// FIXME: There is a (probably minor) optimization we could do here, if
// the macro comes from the original PCH but the identifier comes from a
// chained PCH, by storing the offset into the original PCH rather than
// writing the macro definition a second time.
if (MI->isBuiltinMacro() ||
(Chain && I->first->isFromAST() && MI->isFromAST()))
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
continue;
now that we have an identifier table in the PCH file, finish hooking up macro deserialization. We now correctly install II's in tokens, handle function-like macros, etc. llvm-svn: 68882
2009-04-12 05:15:38 +08:00
AddIdentifierRef(I->first, Record);
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
MacroOffsets[I->first] = Stream.GetCurrentBitNo();
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
Record.push_back(MI->getDefinitionLoc().getRawEncoding());
Record.push_back(MI->isUsed());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
unsigned Code;
if (MI->isObjectLike()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = PP_MACRO_OBJECT_LIKE;
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
} else {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = PP_MACRO_FUNCTION_LIKE;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
Record.push_back(MI->isC99Varargs());
Record.push_back(MI->isGNUVarargs());
Record.push_back(MI->getNumArgs());
for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
I != E; ++I)
now that we have an identifier table in the PCH file, finish hooking up macro deserialization. We now correctly install II's in tokens, handle function-like macros, etc. llvm-svn: 68882
2009-04-12 05:15:38 +08:00
AddIdentifierRef(*I, Record);
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
}
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
// If we have a detailed preprocessing record, record the macro definition
// ID that corresponds to this macro.
if (PPRec)
Record.push_back(getMacroDefinitionID(PPRec->findMacroDefinition(MI)));
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.EmitRecord(Code, Record);
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
Record.clear();
improve punctuation llvm-svn: 68791
2009-04-11 01:16:57 +08:00
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
// Emit the tokens array.
for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
// Note that we know that the preprocessor does not have any annotation
// tokens in it because they are created by the parser, and thus can't be
// in a macro definition.
const Token &Tok = MI->getReplacementToken(TokNo);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
Record.push_back(Tok.getLocation().getRawEncoding());
Record.push_back(Tok.getLength());
// FIXME: When reading literal tokens, reconstruct the literal pointer if
// it is needed.
now that we have an identifier table in the PCH file, finish hooking up macro deserialization. We now correctly install II's in tokens, handle function-like macros, etc. llvm-svn: 68882
2009-04-12 05:15:38 +08:00
AddIdentifierRef(Tok.getIdentifierInfo(), Record);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
// FIXME: Should translate token kind to a stable encoding.
Record.push_back(Tok.getKind());
// FIXME: Should translate token flags to a stable encoding.
Record.push_back(Tok.getFlags());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(PP_TOKEN, Record);
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
Record.clear();
}
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
++NumMacros;
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
}
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
// If the preprocessor has a preprocessing record, emit it.
unsigned NumPreprocessingRecords = 0;
if (PPRec) {
My previous fix was incorrect for non-chained PCH reuse. Fix again. llvm-svn: 114922
2010-09-28 07:20:01 +08:00
unsigned IndexBase = Chain ? PPRec->getNumPreallocatedEntities() : 0;
When chaining PCHs, only write PPRecords that don't come from PCH, and give them the correct IDs. Fixes a crash in XCode. llvm-svn: 114913
2010-09-28 06:18:47 +08:00
for (PreprocessingRecord::iterator E = PPRec->begin(Chain),
EEnd = PPRec->end(Chain);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
E != EEnd; ++E) {
Record.clear();
if (MacroInstantiation *MI = dyn_cast<MacroInstantiation>(*E)) {
When chaining PCHs, only write PPRecords that don't come from PCH, and give them the correct IDs. Fixes a crash in XCode. llvm-svn: 114913
2010-09-28 06:18:47 +08:00
Record.push_back(IndexBase + NumPreprocessingRecords++);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
AddSourceLocation(MI->getSourceRange().getBegin(), Record);
AddSourceLocation(MI->getSourceRange().getEnd(), Record);
AddIdentifierRef(MI->getName(), Record);
Record.push_back(getMacroDefinitionID(MI->getDefinition()));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(PP_MACRO_INSTANTIATION, Record);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
continue;
}
if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) {
// Record this macro definition's location.
Macro definitions in AST files have their own IDs. llvm-svn: 114014
2010-09-16 03:54:06 +08:00
MacroID ID = getMacroDefinitionID(MD);
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
// Don't write the macro definition if it is from another AST file.
if (ID < FirstMacroID)
continue;
unsigned Position = ID - FirstMacroID;
if (Position != MacroDefinitionOffsets.size()) {
if (Position > MacroDefinitionOffsets.size())
MacroDefinitionOffsets.resize(Position + 1);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
MacroDefinitionOffsets[Position] = Stream.GetCurrentBitNo();
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
} else
MacroDefinitionOffsets.push_back(Stream.GetCurrentBitNo());
When chaining PCHs, only write PPRecords that don't come from PCH, and give them the correct IDs. Fixes a crash in XCode. llvm-svn: 114913
2010-09-28 06:18:47 +08:00
Record.push_back(IndexBase + NumPreprocessingRecords++);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Record.push_back(ID);
AddSourceLocation(MD->getSourceRange().getBegin(), Record);
AddSourceLocation(MD->getSourceRange().getEnd(), Record);
AddIdentifierRef(MD->getName(), Record);
AddSourceLocation(MD->getLocation(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(PP_MACRO_DEFINITION, Record);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
continue;
}
}
}
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.ExitBlock();
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
// Write the offsets table for the preprocessing record.
if (NumPreprocessingRecords > 0) {
// Write the offsets table for identifier IDs.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(MACRO_DEFINITION_OFFSETS));
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of records
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macro defs
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned MacroDefOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(MACRO_DEFINITION_OFFSETS);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Record.push_back(NumPreprocessingRecords);
Record.push_back(MacroDefinitionOffsets.size());
Stream.EmitRecordWithBlob(MacroDefOffsetAbbrev, Record,
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
(const char *)data(MacroDefinitionOffsets),
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
MacroDefinitionOffsets.size() * sizeof(uint32_t));
}
Arrange for the preprocessor to be passed down into the PCH writer. llvm-svn: 68790
2009-04-11 01:15:23 +08:00
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// Type Serialization
//===----------------------------------------------------------------------===//
Arrange for the preprocessor to be passed down into the PCH writer. llvm-svn: 68790
2009-04-11 01:15:23 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the representation of a type to the AST stream.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteType(QualType T) {
Rename TypeIDs -> TypeIdxs. No functionality change. llvm-svn: 111631
2010-08-21 00:04:04 +08:00
TypeIdx &Idx = TypeIdxs[T];
serialization::TypeID is used with or without qualifiers, both as index and as index + qualifiers. Disambiguate and provide some type safety by using a new class TypeIdx for the "TypeID as index" semantics. llvm-svn: 111630
2010-08-21 00:03:59 +08:00
if (Idx.getIndex() == 0) // we haven't seen this type before.
Idx = TypeIdx(NextTypeID++);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix a marvelous chained AST writing bug, where we end up with the following amusing sequence: - AST writing schedules writing a type X* that it had never seen before - AST writing starts writing another declaration, ends up deserializing X* from a prior AST file. Now we have two type IDs for the same type! - AST writer tries to write X*. It only has the lower-numbered ID from the the prior AST file, so references to the higher-numbered ID that was scheduled for writing go off into lalaland. To fix this, keep the higher-numbered ID so we end up writing the type twice. Since this issue occurs so rarely, and type records are generally rather small, I deemed this better than the alternative: to keep a separate mapping from the higher-numbered IDs to the lower-numbered IDs, which we would end up having to check whenever we want to deserialize any type. Fixes <rdar://problem/8511624>, I think. llvm-svn: 115647
2010-10-06 02:37:06 +08:00
assert(Idx.getIndex() >= FirstTypeID && "Re-writing a type from a prior AST");
When a type comes from a previously-loaded PCH/AST file, don't try to write it into a chained PCH file. llvm-svn: 115527
2010-10-05 02:21:45 +08:00
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Record the offset for this type.
serialization::TypeID is used with or without qualifiers, both as index and as index + qualifiers. Disambiguate and provide some type safety by using a new class TypeIdx for the "TypeID as index" semantics. llvm-svn: 111630
2010-08-21 00:03:59 +08:00
unsigned Index = Idx.getIndex() - FirstTypeID;
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
if (TypeOffsets.size() == Index)
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
TypeOffsets.push_back(Stream.GetCurrentBitNo());
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
else if (TypeOffsets.size() < Index) {
TypeOffsets.resize(Index + 1);
TypeOffsets[Index] = Stream.GetCurrentBitNo();
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
RecordData Record;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Emit the type's representation.
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter W(*this, Record);
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
First part of changes to eliminate problems with cv-qualifiers and sugared types. The basic problem is that our qualifier accessors (getQualifiers, getCVRQualifiers, isConstQualified, etc.) only look at the current QualType and not at any qualifiers that come from sugared types, meaning that we won't see these qualifiers through, e.g., typedefs: typedef const int CInt; typedef CInt Self; Self.isConstQualified() currently returns false! Various bugs (e.g., PR5383) have cropped up all over the front end due to such problems. I'm addressing this problem by splitting each qualifier accessor into two versions: - the "local" version only returns qualifiers on this particular QualType instance - the "normal" version that will eventually combine qualifiers from this QualType instance with the qualifiers on the canonical type to produce the full set of qualifiers. This commit adds the local versions and switches a few callers from the "normal" version (e.g., isConstQualified) over to the "local" version (e.g., isLocalConstQualified) when that is the right thing to do, e.g., because we're printing or serializing the qualifiers. Also, switch a bunch of Context.getCanonicalType(T1).getUnqualifiedType() == Context.getCanonicalType(T2).getQualifiedType() expressions over to Context.hasSameUnqualifiedType(T1, T2) llvm-svn: 88969
2009-11-17 05:35:15 +08:00
if (T.hasLocalNonFastQualifiers()) {
Qualifiers Qs = T.getLocalQualifiers();
AddTypeRef(T.getLocalUnqualifiedType(), Record);
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
Record.push_back(Qs.getAsOpaqueValue());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
W.Code = TYPE_EXT_QUAL;
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
} else {
switch (T->getTypeClass()) {
// For all of the concrete, non-dependent types, call the
// appropriate visitor function.
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
#define TYPE(Class, Base) \
Use the llvm coding convention for indentation for switch. llvm-svn: 93966
2010-01-20 10:03:14 +08:00
case Type::Class: W.Visit##Class##Type(cast<Class##Type>(T)); break;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
#define ABSTRACT_TYPE(Class, Base)
#include "clang/AST/TypeNodes.def"
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
// Emit the serialized record.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.EmitRecord(W.Code, Record);
PCH support for a few very, very simple kinds of expressions. Hook up expression (de-)serialization for VLAs, variable initializers, enum constant initializers, and bitfield widths. llvm-svn: 69075
2009-04-15 05:18:50 +08:00
// Flush any expressions that were written as part of this type.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
FlushStmts();
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// Declaration Serialization
//===----------------------------------------------------------------------===//
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
/// \brief Write the block containing all of the declaration IDs
/// lexically declared within the given DeclContext.
///
/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
/// bistream, or 0 if no block was written.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
DeclContext *DC) {
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
if (DC->decls_empty())
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
return 0;
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
uint64_t Offset = Stream.GetCurrentBitNo();
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(DECL_CONTEXT_LEXICAL);
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
llvm::SmallVector<KindDeclIDPair, 64> Decls;
De-ASTContext-ify DeclContext. Remove ASTContext parameter from DeclContext's methods. This change cascaded down to other Decl's methods and changes to call sites started "escalating". Timings using pre-tokenized "cocoa.h" showed only a ~1% increase in time run between and after this commit. llvm-svn: 74506
2009-06-30 10:36:12 +08:00
for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
D != DEnd; ++D)
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
Decls.push_back(std::make_pair((*D)->getKind(), GetDeclRef(*D)));
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Add PCH statistics for the number/percent of lexical/visible declcontexts read llvm-svn: 69835
2009-04-23 06:34:57 +08:00
++NumLexicalDeclContexts;
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record,
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
reinterpret_cast<char*>(Decls.data()),
Decls.size() * sizeof(KindDeclIDPair));
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
return Offset;
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteTypeDeclOffsets() {
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
using namespace llvm;
RecordData Record;
// Write the type offsets array
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(TYPE_OFFSET));
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of types
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // types block
unsigned TypeOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(TYPE_OFFSET);
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
Record.push_back(TypeOffsets.size());
Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record,
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
(const char *)data(TypeOffsets),
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
TypeOffsets.size() * sizeof(TypeOffsets[0]));
// Write the declaration offsets array
Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(DECL_OFFSET));
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of declarations
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // declarations block
unsigned DeclOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(DECL_OFFSET);
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
Record.push_back(DeclOffsets.size());
Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record,
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
(const char *)data(DeclOffsets),
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
DeclOffsets.size() * sizeof(DeclOffsets[0]));
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// Global Method Pool and Selector Serialization
//===----------------------------------------------------------------------===//
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
namespace {
// Trait used for the on-disk hash table used in the method pool.
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
class ASTMethodPoolTrait {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter &Writer;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
public:
typedef Selector key_type;
typedef key_type key_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
struct data_type {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
SelectorID ID;
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
ObjCMethodList Instance, Factory;
};
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
typedef const data_type& data_type_ref;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
explicit ASTMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { }
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
static unsigned ComputeHash(Selector Sel) {
Share the common code of ComputeHash(Selector Sel) instead of keeping 2 copies in PCHReader and PCHWriter. No functionality change. llvm-svn: 111629
2010-08-21 00:03:52 +08:00
return serialization::ComputeHash(Sel);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<unsigned,unsigned>
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
EmitKeyDataLength(llvm::raw_ostream& Out, Selector Sel,
data_type_ref Methods) {
unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
clang::io::Emit16(Out, KeyLen);
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
for (const ObjCMethodList *Method = &Methods.Instance; Method;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Method = Method->Next)
if (Method->Method)
DataLen += 4;
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
for (const ObjCMethodList *Method = &Methods.Factory; Method;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Method = Method->Next)
if (Method->Method)
DataLen += 4;
clang::io::Emit16(Out, DataLen);
return std::make_pair(KeyLen, DataLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
void EmitKey(llvm::raw_ostream& Out, Selector Sel, unsigned) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
uint64_t Start = Out.tell();
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
assert((Start >> 32) == 0 && "Selector key offset too large");
Writer.SetSelectorOffset(Sel, Start);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
unsigned N = Sel.getNumArgs();
clang::io::Emit16(Out, N);
if (N == 0)
N = 1;
for (unsigned I = 0; I != N; ++I)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
clang::io::Emit32(Out,
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
void EmitData(llvm::raw_ostream& Out, key_type_ref,
Fix two small but very nasty bugs in the PCH writer for method pools: (1) Make sure to pad on-disk hash tables with 4 bytes, not 2, since the reader assumes that bucket data is aligned on 4-byte boundaries. (2) Don't emit the number of factory methods twice. This was throwing off the data counts and therefore causing lookups to fail. I've added asserts so that this class of error cannot happen again. llvm-svn: 69991
2009-04-25 05:49:02 +08:00
data_type_ref Methods, unsigned DataLen) {
uint64_t Start = Out.tell(); (void)Start;
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
clang::io::Emit32(Out, Methods.ID);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
unsigned NumInstanceMethods = 0;
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
for (const ObjCMethodList *Method = &Methods.Instance; Method;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Method = Method->Next)
if (Method->Method)
++NumInstanceMethods;
unsigned NumFactoryMethods = 0;
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
for (const ObjCMethodList *Method = &Methods.Factory; Method;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Method = Method->Next)
if (Method->Method)
++NumFactoryMethods;
clang::io::Emit16(Out, NumInstanceMethods);
clang::io::Emit16(Out, NumFactoryMethods);
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
for (const ObjCMethodList *Method = &Methods.Instance; Method;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Method = Method->Next)
if (Method->Method)
clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
for (const ObjCMethodList *Method = &Methods.Factory; Method;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Method = Method->Next)
if (Method->Method)
clang::io::Emit32(Out, Writer.getDeclID(Method->Method));
Fix two small but very nasty bugs in the PCH writer for method pools: (1) Make sure to pad on-disk hash tables with 4 bytes, not 2, since the reader assumes that bucket data is aligned on 4-byte boundaries. (2) Don't emit the number of factory methods twice. This was throwing off the data counts and therefore causing lookups to fail. I've added asserts so that this class of error cannot happen again. llvm-svn: 69991
2009-04-25 05:49:02 +08:00
assert(Out.tell() - Start == DataLen && "Data length is wrong");
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
};
} // end anonymous namespace
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
/// \brief Write ObjC data: selectors and the method pool.
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
///
/// The method pool contains both instance and factory methods, stored
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
/// in an on-disk hash table indexed by the selector. The hash table also
/// contains an empty entry for every other selector known to Sema.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteSelectors(Sema &SemaRef) {
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
using namespace llvm;
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
// Do we have to do anything at all?
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
if (SemaRef.MethodPool.empty() && SelectorIDs.empty())
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
return;
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
unsigned NumTableEntries = 0;
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
// Create and write out the blob that contains selectors and the method pool.
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
ASTMethodPoolTrait Trait(*this);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
// Create the on-disk hash table representation. We walk through every
// selector we've seen and look it up in the method pool.
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
SelectorOffsets.resize(NextSelectorID - FirstSelectorID);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
for (llvm::DenseMap<Selector, SelectorID>::iterator
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
I = SelectorIDs.begin(), E = SelectorIDs.end();
I != E; ++I) {
Selector S = I->first;
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
Sema::GlobalMethodPool::iterator F = SemaRef.MethodPool.find(S);
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTMethodPoolTrait::data_type Data = {
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
I->second,
ObjCMethodList(),
ObjCMethodList()
};
if (F != SemaRef.MethodPool.end()) {
Data.Instance = F->second.first;
Data.Factory = F->second.second;
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Only write this selector if it's not in an existing AST or something
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
// changed.
if (Chain && I->second < FirstSelectorID) {
// Selector already exists. Did it change?
bool changed = false;
for (ObjCMethodList *M = &Data.Instance; !changed && M && M->Method;
M = M->Next) {
if (M->Method->getPCHLevel() == 0)
changed = true;
}
for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method;
M = M->Next) {
if (M->Method->getPCHLevel() == 0)
changed = true;
}
if (!changed)
continue;
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
} else if (Data.Instance.Method || Data.Factory.Method) {
// A new method pool entry.
++NumTableEntries;
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
}
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
Generator.insert(S, Data, Trait);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
// Create the on-disk hash table in a buffer.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallString<4096> MethodPool;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
uint32_t BucketOffset;
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTMethodPoolTrait Trait(*this);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
llvm::raw_svector_ostream Out(MethodPool);
// Make sure that no bucket is at offset 0
Fix two small but very nasty bugs in the PCH writer for method pools: (1) Make sure to pad on-disk hash tables with 4 bytes, not 2, since the reader assumes that bucket data is aligned on 4-byte boundaries. (2) Don't emit the number of factory methods twice. This was throwing off the data counts and therefore causing lookups to fail. I've added asserts so that this class of error cannot happen again. llvm-svn: 69991
2009-04-25 05:49:02 +08:00
clang::io::Emit32(Out, 0);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
BucketOffset = Generator.Emit(Out, Trait);
}
// Create a blob abbreviation
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev);
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
// Write the method pool
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(METHOD_POOL);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Record.push_back(BucketOffset);
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
Record.push_back(NumTableEntries);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str());
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
// Create a blob abbreviation for the selector table offsets.
Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // index
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned SelectorOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
// Write the selector offsets table.
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(SELECTOR_OFFSETS);
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
Record.push_back(SelectorOffsets.size());
Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
(const char *)data(SelectorOffsets),
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
SelectorOffsets.size() * 4);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the selectors referenced in @selector expression into AST file.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
using namespace llvm;
if (SemaRef.ReferencedSelectors.empty())
return;
Implement per-file reading of the selector table. This disables statistics about method pool hits for the moment. llvm-svn: 110245
2010-08-05 04:40:17 +08:00
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
RecordData Record;
Implement per-file reading of the selector table. This disables statistics about method pool hits for the moment. llvm-svn: 110245
2010-08-05 04:40:17 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Note: this writes out all references even for a dependent AST. But it is
Activate selectors in chained PCH. Chained PCH now works for Objective-C. llvm-svn: 110262
2010-08-05 06:21:29 +08:00
// very tricky to fix, and given that @selector shouldn't really appear in
// headers, probably not worth it. It's not a correctness issue.
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
for (DenseMap<Selector, SourceLocation>::iterator S =
SemaRef.ReferencedSelectors.begin(),
E = SemaRef.ReferencedSelectors.end(); S != E; ++S) {
Selector Sel = (*S).first;
SourceLocation Loc = (*S).second;
AddSelectorRef(Sel, Record);
AddSourceLocation(Loc, Record);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(REFERENCED_SELECTOR_POOL, Record);
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// Identifier Table Serialization
//===----------------------------------------------------------------------===//
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
namespace {
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
class ASTIdentifierTableTrait {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter &Writer;
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
Preprocessor &PP;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
/// \brief Determines whether this is an "interesting" identifier
/// that needs a full IdentifierInfo structure written into the hash
/// table.
static bool isInterestingIdentifier(const IdentifierInfo *II) {
return II->isPoisoned() ||
II->isExtensionToken() ||
II->hasMacroDefinition() ||
II->getObjCOrBuiltinID() ||
II->getFETokenInfo<void>();
}
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
public:
typedef const IdentifierInfo* key_type;
typedef key_type key_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
typedef IdentID data_type;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
typedef data_type data_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP)
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
: Writer(Writer), PP(PP) { }
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
static unsigned ComputeHash(const IdentifierInfo* II) {
Switch to llvm::HashString. llvm-svn: 84375
2009-10-18 07:52:28 +08:00
return llvm::HashString(II->getName());
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<unsigned,unsigned>
EmitKeyDataLength(llvm::raw_ostream& Out, const IdentifierInfo* II,
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ID) {
Move clients to use IdentifierInfo::getNameStart() instead of getName() llvm-svn: 84436
2009-10-19 04:26:12 +08:00
unsigned KeyLen = II->getLength() + 1;
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
if (isInterestingIdentifier(II)) {
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
DataLen += 2; // 2 bytes for builtin ID, flags
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (II->hasMacroDefinition() &&
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
!PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro())
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
DataLen += 4;
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
for (IdentifierResolver::iterator D = IdentifierResolver::begin(II),
DEnd = IdentifierResolver::end();
D != DEnd; ++D)
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DataLen += sizeof(DeclID);
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
}
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
clang::io::Emit16(Out, DataLen);
Revert r70075 and r70078, which reorganized the PCH on-disk hash table for identifiers to separate "interesting" from "uninteresting" identifiers. However, to cope with compiler invocations where the predefines buffers mismatch, we need to be able to search the complete identifier table. Cocoa.h.pch is now about 500k larger that it used to be :( llvm-svn: 70320
2009-04-29 04:01:51 +08:00
// We emit the key length after the data length so that every
// string is preceded by a 16-bit length. This matches the PTH
// format for storing identifiers.
PCH optimization for the identifier table, where we separate "interesting" identifiers (e.g., those where the IdentifierInfo has some useful information) from "uninteresting" identifiers (where the IdentifierInfo is just a name). This makes the hash table smaller (so searching in it should be faster) and, when loading "uninteresting" identifiers, we skip the lookup in the hash table. PCH file size is slightly smaller than before (since we don't emit the contents of the uninteresting IdentifierInfo structures). The Cocoa.h-prefixed "Hello, World" doesn't show any speedup, although we're getting to the point where system noise is a bit issue. llvm-svn: 70075
2009-04-26 05:04:17 +08:00
clang::io::Emit16(Out, KeyLen);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
return std::make_pair(KeyLen, DataLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void EmitKey(llvm::raw_ostream& Out, const IdentifierInfo* II,
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
unsigned KeyLen) {
// Record the location of the key data. This is used when generating
// the mapping from persistent IDs to strings.
Writer.SetIdentifierOffset(II, Out.tell());
Move clients to use IdentifierInfo::getNameStart() instead of getName() llvm-svn: 84436
2009-10-19 04:26:12 +08:00
Out.write(II->getNameStart(), KeyLen);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void EmitData(llvm::raw_ostream& Out, const IdentifierInfo* II,
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ID, unsigned) {
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
if (!isInterestingIdentifier(II)) {
clang::io::Emit32(Out, ID << 1);
return;
}
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
clang::io::Emit32(Out, (ID << 1) | 0x01);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
uint32_t Bits = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
bool hasMacroDefinition =
II->hasMacroDefinition() &&
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
!PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro();
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
Bits = (uint32_t)II->getObjCOrBuiltinID();
Fix a few MSVC warnings. llvm-svn: 91714
2009-12-19 04:58:47 +08:00
Bits = (Bits << 1) | unsigned(hasMacroDefinition);
Bits = (Bits << 1) | unsigned(II->isExtensionToken());
Bits = (Bits << 1) | unsigned(II->isPoisoned());
-Make TokenID of IdentifierInfo read-only, remove setTokenID(). -There are 2 instances that change the TokenID for GNU libstdc++ 4.2 compatibility. To handler those cases introduce a RevertedTokenID bitfield, RevertTokenIDToIdentifier() and hasRevertedTokenIDToIdentifier() methods. Store the bitfield in PCH. llvm-svn: 110868
2010-08-12 06:55:12 +08:00
Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
Fix a few MSVC warnings. llvm-svn: 91714
2009-12-19 04:58:47 +08:00
Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
clang::io::Emit16(Out, Bits);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
if (hasMacroDefinition)
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
clang::io::Emit32(Out, Writer.getMacroOffset(II));
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
// Emit the declaration IDs in reverse order, because the
// IdentifierResolver provides the declarations as they would be
// visible (e.g., the function "stat" would come before the struct
// "stat"), but IdentifierResolver::AddDeclToIdentifierChain()
// adds declarations to the end of the list (so we need to see the
// struct "status" before the function "status").
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
// Only emit declarations that aren't from a chained PCH, though.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II),
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
IdentifierResolver::end());
for (llvm::SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(),
DEnd = Decls.rend();
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
D != DEnd; ++D)
Query only the latest version of an identifier in the PCH chain. Make sure this version holds the entire declaration chain. This is a much saner solution than trying to merge the info from all elements, and makes redeclarations work properly. Expand the declarations test case to cover more compliated cases. llvm-svn: 110052
2010-08-03 02:30:12 +08:00
clang::io::Emit32(Out, Writer.getDeclID(*D));
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
};
} // end anonymous namespace
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the identifier table into the AST file.
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
///
/// The identifier table consists of a blob containing string data
/// (the actual identifiers themselves) and a separate "offsets" index
/// that maps identifier IDs to locations within the blob.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteIdentifierTable(Preprocessor &PP) {
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
using namespace llvm;
// Create and write out the blob that contains the identifier
// strings.
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
ASTIdentifierTableTrait Trait(*this, PP);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement checking for macro definitions that occur on the command line when using a PCH that were not provided when building the PCH file. If those names were used as identifiers somewhere in the PCH file, reject the PCH file. llvm-svn: 70321
2009-04-29 04:33:11 +08:00
// Look for any identifiers that were named while processing the
// headers, but are otherwise not needed. We add these to the hash
// table to enable checking of the predefines buffer in the case
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// where the user adds new macro definitions when building the AST
Implement checking for macro definitions that occur on the command line when using a PCH that were not provided when building the PCH file. If those names were used as identifiers somewhere in the PCH file, reject the PCH file. llvm-svn: 70321
2009-04-29 04:33:11 +08:00
// file.
for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
IDEnd = PP.getIdentifierTable().end();
ID != IDEnd; ++ID)
getIdentifierRef(ID->second);
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
// Create the on-disk hash table representation. We only store offsets
// for identifiers that appear here for the first time.
IdentifierOffsets.resize(NextIdentID - FirstIdentID);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end();
ID != IDEnd; ++ID) {
assert(ID->first && "NULL identifier in identifier table");
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
if (!Chain || !ID->first->isFromAST())
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
Generator.insert(ID->first, ID->second, Trait);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
// Create the on-disk hash table in a buffer.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallString<4096> IdentifierTable;
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
uint32_t BucketOffset;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTIdentifierTableTrait Trait(*this, PP);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
llvm::raw_svector_ostream Out(IdentifierTable);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
// Make sure that no bucket is at offset 0
Fix two small but very nasty bugs in the PCH writer for method pools: (1) Make sure to pad on-disk hash tables with 4 bytes, not 2, since the reader assumes that bucket data is aligned on 4-byte boundaries. (2) Don't emit the number of factory methods twice. This was throwing off the data counts and therefore causing lookups to fail. I've added asserts so that this class of error cannot happen again. llvm-svn: 69991
2009-04-25 05:49:02 +08:00
clang::io::Emit32(Out, 0);
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
BucketOffset = Generator.Emit(Out, Trait);
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
}
// Create a blob abbreviation
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev);
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
// Write the identifier table
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(IDENTIFIER_TABLE);
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
Record.push_back(BucketOffset);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
}
// Write the offsets table for identifier IDs.
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(IDENTIFIER_OFFSET);
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
Record.push_back(IdentifierOffsets.size());
Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
(const char *)data(IdentifierOffsets),
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
IdentifierOffsets.size() * sizeof(uint32_t));
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
}
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
//===----------------------------------------------------------------------===//
// DeclContext's Name Lookup Table Serialization
//===----------------------------------------------------------------------===//
namespace {
// Trait used for the on-disk hash table used in the method pool.
class ASTDeclContextNameLookupTrait {
ASTWriter &Writer;
public:
typedef DeclarationName key_type;
typedef key_type key_type_ref;
typedef DeclContext::lookup_result data_type;
typedef const data_type& data_type_ref;
explicit ASTDeclContextNameLookupTrait(ASTWriter &Writer) : Writer(Writer) { }
unsigned ComputeHash(DeclarationName Name) {
llvm::FoldingSetNodeID ID;
ID.AddInteger(Name.getNameKind());
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
ID.AddString(Name.getAsIdentifierInfo()->getName());
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
ID.AddInteger(serialization::ComputeHash(Name.getObjCSelector()));
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
ID.AddInteger(Writer.GetOrCreateTypeID(Name.getCXXNameType()));
break;
case DeclarationName::CXXOperatorName:
ID.AddInteger(Name.getCXXOverloadedOperator());
break;
case DeclarationName::CXXLiteralOperatorName:
ID.AddString(Name.getCXXLiteralIdentifier()->getName());
case DeclarationName::CXXUsingDirective:
break;
}
return ID.ComputeHash();
}
std::pair<unsigned,unsigned>
EmitKeyDataLength(llvm::raw_ostream& Out, DeclarationName Name,
data_type_ref Lookup) {
unsigned KeyLen = 1;
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXLiteralOperatorName:
KeyLen += 4;
break;
case DeclarationName::CXXOperatorName:
KeyLen += 1;
break;
case DeclarationName::CXXUsingDirective:
break;
}
clang::io::Emit16(Out, KeyLen);
// 2 bytes for num of decls and 4 for each DeclID.
unsigned DataLen = 2 + 4 * (Lookup.second - Lookup.first);
clang::io::Emit16(Out, DataLen);
return std::make_pair(KeyLen, DataLen);
}
void EmitKey(llvm::raw_ostream& Out, DeclarationName Name, unsigned) {
using namespace clang::io;
assert(Name.getNameKind() < 0x100 && "Invalid name kind ?");
Emit8(Out, Name.getNameKind());
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector()));
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
Emit32(Out, Writer.getTypeID(Name.getCXXNameType()));
break;
case DeclarationName::CXXOperatorName:
assert(Name.getCXXOverloadedOperator() < 0x100 && "Invalid operator ?");
Emit8(Out, Name.getCXXOverloadedOperator());
break;
case DeclarationName::CXXLiteralOperatorName:
Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
break;
case DeclarationName::CXXUsingDirective:
break;
}
}
void EmitData(llvm::raw_ostream& Out, key_type_ref,
data_type Lookup, unsigned DataLen) {
uint64_t Start = Out.tell(); (void)Start;
clang::io::Emit16(Out, Lookup.second - Lookup.first);
for (; Lookup.first != Lookup.second; ++Lookup.first)
clang::io::Emit32(Out, Writer.GetDeclRef(*Lookup.first));
assert(Out.tell() - Start == DataLen && "Data length is wrong");
}
};
} // end anonymous namespace
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
/// \brief Write the block containing all of the declaration IDs
/// visible from the given DeclContext.
///
/// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
/// bitstream, or 0 if no block was written.
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
DeclContext *DC) {
if (DC->getPrimaryContext() != DC)
return 0;
// Since there is no name lookup into functions or methods, don't bother to
// build a visible-declarations table for these entities.
if (DC->isFunctionOrMethod())
return 0;
// If not in C++, we perform name lookup for the translation unit via the
// IdentifierInfo chains, don't bother to build a visible-declarations table.
// FIXME: In C++ we need the visible declarations in order to "see" the
// friend declarations, is there a way to do this without writing the table ?
if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus)
return 0;
// Force the DeclContext to build a its name-lookup table.
Fix an issue with writing to PCH another included PCH, introduced by the "using an AST on-disk hash table for name lookup" commit. When including a PCH and later re-emitting to another PCH, the name lookup tables of DeclContexts may be incomplete, since we now lazily deserialize the visible decls of a particular name. Fix the issue by iterating over the un-deserialized visible decls and completing the lookup tables of DeclContexts before writing them out. llvm-svn: 111698
2010-08-21 07:35:55 +08:00
if (DC->hasExternalVisibleStorage())
DC->MaterializeVisibleDeclsFromExternalStorage();
else
DC->lookup(DeclarationName());
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
// Serialize the contents of the mapping used for lookup. Note that,
// although we have two very different code paths, the serialized
// representation is the same for both cases: a declaration name,
// followed by a size, followed by references to the visible
// declarations that have that name.
uint64_t Offset = Stream.GetCurrentBitNo();
StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
if (!Map || Map->empty())
return 0;
OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
ASTDeclContextNameLookupTrait Trait(*this);
// Create the on-disk hash table representation.
for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
D != DEnd; ++D) {
DeclarationName Name = D->first;
DeclContext::lookup_result Result = D->second.getLookupResult();
Generator.insert(Name, Result, Trait);
}
// Create the on-disk hash table in a buffer.
llvm::SmallString<4096> LookupTable;
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(LookupTable);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}
// Write the lookup table
RecordData Record;
Record.push_back(DECL_CONTEXT_VISIBLE);
Record.push_back(BucketOffset);
Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
LookupTable.str());
Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record);
++NumVisibleDeclContexts;
return Offset;
}
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
/// \brief Write an UPDATE_VISIBLE block for the given context.
///
/// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
/// DeclContext in a dependent AST file. As such, they only exist for the TU
/// (in C++) and for namespaces.
void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
assert((DC->isTranslationUnit() || DC->isNamespace()) &&
"Only TU and namespaces should have visible decl updates.");
// Make the context build its lookup table, but don't make it load external
// decls.
DC->lookup(DeclarationName());
StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
if (!Map || Map->empty())
return;
OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
ASTDeclContextNameLookupTrait Trait(*this);
// Create the hash table.
for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
D != DEnd; ++D) {
DeclarationName Name = D->first;
DeclContext::lookup_result Result = D->second.getLookupResult();
Add testcase for C++ chained PCH and fix the bugs it uncovered in name lookup. llvm-svn: 111882
2010-08-24 08:50:16 +08:00
// For any name that appears in this table, the results are complete, i.e.
// they overwrite results from previous PCHs. Merging is always a mess.
Generator.insert(Name, Result, Trait);
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
}
// Create the on-disk hash table in a buffer.
llvm::SmallString<4096> LookupTable;
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(LookupTable);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}
// Write the lookup table
RecordData Record;
Record.push_back(UPDATE_VISIBLE);
Record.push_back(getDeclID(cast<Decl>(DC)));
Record.push_back(BucketOffset);
Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str());
}
AST writer support for having specializations of templates from earlier in the chain. This ought to finish C++ chained PCH support. llvm-svn: 111986
2010-08-25 06:50:24 +08:00
/// \brief Write ADDITIONAL_TEMPLATE_SPECIALIZATIONS blocks for all templates
/// that have new specializations in the current AST file.
void ASTWriter::WriteAdditionalTemplateSpecializations() {
RecordData Record;
for (AdditionalTemplateSpecializationsMap::iterator
I = AdditionalTemplateSpecializations.begin(),
E = AdditionalTemplateSpecializations.end();
I != E; ++I) {
Record.clear();
Record.push_back(I->first);
Record.insert(Record.end(), I->second.begin(), I->second.end());
Stream.EmitRecord(ADDITIONAL_TEMPLATE_SPECIALIZATIONS, Record);
}
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// General Serialization Routines
//===----------------------------------------------------------------------===//
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
/// \brief Write a record containing the given attributes.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteAttributeRecord(const AttrVec &Attrs) {
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
RecordData Record;
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){
const Attr * A = *i;
Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
AddSourceLocation(A->getLocation(), Record);
Record.push_back(A->isInherited());
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
#include "clang/Serialization/AttrPCHWrite.inc"
implementation of format_arg for ObjC methods/functions. Still more to do. llvm-svn: 72173
2009-05-21 01:41:43 +08:00
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(DECL_ATTR, Record);
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
}
Avoid implicit string construction. llvm-svn: 112820
2010-09-02 23:06:24 +08:00
void ASTWriter::AddString(llvm::StringRef Str, RecordData &Record) {
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
Record.push_back(Str.size());
Record.insert(Record.end(), Str.begin(), Str.end());
}
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
/// \brief Note that the identifier II occurs at the given offset
/// within the identifier table.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ID = IdentifierIDs[II];
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Only store offsets new to this AST file. Other identifier names are looked
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
// up earlier in the chain and thus don't need an offset.
if (ID >= FirstIdentID)
IdentifierOffsets[ID - FirstIdentID] = Offset;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
/// \brief Note that the selector Sel occurs at the given offset
/// within the method pool/selector table.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
unsigned ID = SelectorIDs[Sel];
assert(ID && "Unknown selector");
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
// Don't record offsets for selectors that are also available in a different
// file.
if (ID < FirstSelectorID)
return;
SelectorOffsets[ID - FirstSelectorID] = Offset;
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream)
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
: Stream(Stream), Chain(0), FirstDeclID(1), NextDeclID(FirstDeclID),
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
FirstTypeID(NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID),
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
FirstIdentID(1), NextIdentID(FirstIdentID), FirstSelectorID(1),
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
NextSelectorID(FirstSelectorID), FirstMacroID(1), NextMacroID(FirstMacroID),
CollectedStmts(&StmtsToEmit),
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0),
NumVisibleDeclContexts(0) {
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls,
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
const char *isysroot) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Emit the file header.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.Emit((unsigned)'C', 8);
Stream.Emit((unsigned)'P', 8);
Stream.Emit((unsigned)'C', 8);
Stream.Emit((unsigned)'H', 8);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
WriteBlockInfoBlock();
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
if (Chain)
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
WriteASTChain(SemaRef, StatCalls, isysroot);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
else
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
WriteASTCore(SemaRef, StatCalls, isysroot);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
const char *isysroot) {
using namespace llvm;
ASTContext &Context = SemaRef.Context;
Preprocessor &PP = SemaRef.PP;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// The translation unit is the first declaration we'll emit.
DeclIDs[Context.getTranslationUnitDecl()] = 1;
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
++NextDeclID;
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
DeclTypesToEmit.push(Context.getTranslationUnitDecl());
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
// Make sure that we emit IdentifierInfos (and any attached
// declarations) for builtins.
{
IdentifierTable &Table = PP.getIdentifierTable();
llvm::SmallVector<const char *, 32> BuiltinNames;
Context.BuiltinInfo.GetBuiltinNames(BuiltinNames,
Context.getLangOptions().NoBuiltin);
for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I)
getIdentifierRef(&Table.get(BuiltinNames[I]));
}
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// Build a record containing all of the tentative definitions in this file, in
Add VarDecl::isThisDeclarationADefinition(), which properly encapsulates the logic for when a variable declaration is a (possibly tentativ) definition. Add a few functions building on this, and shift C tentative definition handling over to this new functionality. This shift also kills the Sema::TentativeDefinitions map and instead simply stores all declarations in the renamed list. The correct handling for multiple tentative definitions is instead shifted to the final walk of the list. llvm-svn: 94968
2010-02-01 06:27:38 +08:00
// TentativeDefinitions order. Generally, this record will be empty for
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// headers.
Support tentative definitions in precompiled headers. This isn't likely to happen (ever), but at least we'll do the right thing when it does. llvm-svn: 69829
2009-04-23 06:02:47 +08:00
RecordData TentativeDefinitions;
Add VarDecl::isThisDeclarationADefinition(), which properly encapsulates the logic for when a variable declaration is a (possibly tentativ) definition. Add a few functions building on this, and shift C tentative definition handling over to this new functionality. This shift also kills the Sema::TentativeDefinitions map and instead simply stores all declarations in the renamed list. The correct handling for multiple tentative definitions is instead shifted to the final walk of the list. llvm-svn: 94968
2010-02-01 06:27:38 +08:00
for (unsigned i = 0, e = SemaRef.TentativeDefinitions.size(); i != e; ++i) {
AddDeclRef(SemaRef.TentativeDefinitions[i], TentativeDefinitions);
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
}
Support tentative definitions in precompiled headers. This isn't likely to happen (ever), but at least we'll do the right thing when it does. llvm-svn: 69829
2009-04-23 06:02:47 +08:00
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
// Build a record containing all of the file scoped decls in this file.
RecordData UnusedFileScopedDecls;
for (unsigned i=0, e = SemaRef.UnusedFileScopedDecls.size(); i !=e; ++i)
AddDeclRef(SemaRef.UnusedFileScopedDecls[i], UnusedFileScopedDecls);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
Support #pragma weak for PCH. llvm-svn: 110323
2010-08-05 17:48:08 +08:00
RecordData WeakUndeclaredIdentifiers;
if (!SemaRef.WeakUndeclaredIdentifiers.empty()) {
WeakUndeclaredIdentifiers.push_back(
SemaRef.WeakUndeclaredIdentifiers.size());
for (llvm::DenseMap<IdentifierInfo*,Sema::WeakInfo>::iterator
I = SemaRef.WeakUndeclaredIdentifiers.begin(),
E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) {
AddIdentifierRef(I->first, WeakUndeclaredIdentifiers);
AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers);
AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers);
WeakUndeclaredIdentifiers.push_back(I->second.getUsed());
}
}
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
// Build a record containing all of the locally-scoped external
// declarations in this header file. Generally, this record will be
// empty.
RecordData LocallyScopedExternalDecls;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// FIXME: This is filling in the AST file in densemap order which is
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// nondeterminstic!
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
TD = SemaRef.LocallyScopedExternalDecls.begin(),
TDEnd = SemaRef.LocallyScopedExternalDecls.end();
TD != TDEnd; ++TD)
AddDeclRef(TD->second, LocallyScopedExternalDecls);
Add Sema::ExtVectorDecls and Sema::ObjCCategoryImpls to the PCH file. Since these vectors are very, very rarely used and, when used in headers, and even when used are relatively small, we load them eagerly. llvm-svn: 70240
2009-04-28 04:06:05 +08:00
// Build a record containing all of the ext_vector declarations.
RecordData ExtVectorDecls;
for (unsigned I = 0, N = SemaRef.ExtVectorDecls.size(); I != N; ++I)
AddDeclRef(SemaRef.ExtVectorDecls[I], ExtVectorDecls);
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
// Build a record containing all of the VTable uses information.
RecordData VTableUses;
Avoid writing a VTABLE_USES record in PCH if there are no entries. llvm-svn: 110122
2010-08-04 01:29:52 +08:00
if (!SemaRef.VTableUses.empty()) {
VTableUses.push_back(SemaRef.VTableUses.size());
for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
}
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
}
// Build a record containing all of dynamic classes declarations.
RecordData DynamicClasses;
for (unsigned I = 0, N = SemaRef.DynamicClasses.size(); I != N; ++I)
AddDeclRef(SemaRef.DynamicClasses[I], DynamicClasses);
Store the pending implicit instantiations in the PCH and perform them at the end of the translation unit that included the PCH, as God intended. llvm-svn: 110324
2010-08-05 17:48:16 +08:00
// Build a record containing all of pending implicit instantiations.
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
RecordData PendingInstantiations;
Store the pending implicit instantiations in the PCH and perform them at the end of the translation unit that included the PCH, as God intended. llvm-svn: 110324
2010-08-05 17:48:16 +08:00
for (std::deque<Sema::PendingImplicitInstantiation>::iterator
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
I = SemaRef.PendingInstantiations.begin(),
N = SemaRef.PendingInstantiations.end(); I != N; ++I) {
AddDeclRef(I->first, PendingInstantiations);
AddSourceLocation(I->second, PendingInstantiations);
Store the pending implicit instantiations in the PCH and perform them at the end of the translation unit that included the PCH, as God intended. llvm-svn: 110324
2010-08-05 17:48:16 +08:00
}
assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
"There are local ones at end of translation unit!");
Read/write in PCH Sema's StdNamespace and StdBadAlloc and use a LazyDeclPtr for them that will deserialize them when needed. llvm-svn: 110031
2010-08-02 15:14:54 +08:00
// Build a record containing some declaration references.
RecordData SemaDeclRefs;
if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) {
AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Write the remaining AST contents.
Store the type ID for __builtin_va_list in the PCH file, so that the AST context's __builtin_va_list type will be set when the PCH file is loaded. This fixes the crash when CodeGen'ing a va_arg expression pulled in from a PCH file. llvm-svn: 69421
2009-04-18 13:55:16 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EnterSubblock(AST_BLOCK_ID, 5);
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
WriteMetadata(Context, isysroot);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
WriteLanguageOptions(Context.getLangOptions());
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
if (StatCalls && !isysroot)
Fix a documentation paste-o and eliminate a useless function parameter, both found by Sebastian llvm-svn: 108214
2010-07-13 07:48:14 +08:00
WriteStatCache(*StatCalls);
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
Remove ObjCQualifiedInterfaceType:-) llvm-svn: 76321
2009-07-18 23:33:26 +08:00
// Write the record of special types.
Record.clear();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Remove ObjCQualifiedInterfaceType:-) llvm-svn: 76321
2009-07-18 23:33:26 +08:00
AddTypeRef(Context.getBuiltinVaListType(), Record);
AddTypeRef(Context.getObjCIdType(), Record);
AddTypeRef(Context.getObjCSelType(), Record);
AddTypeRef(Context.getObjCProtoType(), Record);
AddTypeRef(Context.getObjCClassType(), Record);
AddTypeRef(Context.getRawCFConstantStringType(), Record);
AddTypeRef(Context.getRawObjCFastEnumerationStateType(), Record);
AddTypeRef(Context.getFILEType(), Record);
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
AddTypeRef(Context.getjmp_bufType(), Record);
AddTypeRef(Context.getsigjmp_bufType(), Record);
Make the new Objective-C "id" and "Class" redefinition types special types that are preloaded by the PCH file. Fixes PCH breakage introduced in r79248. llvm-svn: 79583
2009-08-21 08:27:50 +08:00
AddTypeRef(Context.ObjCIdRedefinitionType, Record);
AddTypeRef(Context.ObjCClassRedefinitionType, Record);
Refine the type of the first parameter to block invoke functions. WIP. I have yet to find the magic incantation to get the structure type to be defined. If someone has a pointer, love to hear it. llvm-svn: 84590
2009-10-20 10:12:22 +08:00
AddTypeRef(Context.getRawBlockdescriptorType(), Record);
Extend out the block descriptor structure for debug information with the copy/dispose helpers as appropriate. llvm-svn: 84817
2009-10-22 08:49:09 +08:00
AddTypeRef(Context.getRawBlockdescriptorExtendedType(), Record);
More work toward implementing NeXt's -fno-constant-cfstrings - wip. llvm-svn: 102189
2010-04-24 01:41:07 +08:00
AddTypeRef(Context.ObjCSelRedefinitionType, Record);
AddTypeRef(Context.getRawNSConstantStringType(), Record);
Don't try to install the __[u]int128_t identifier if it is already installed by PCHReader. Currently, adding it to visible decls of a PCH'ed translation unit has no effect because adding visible decls before deserialization has no effect (the decls won't be visible). This will be fixed in a future commit; then it will force deserialization of visible decls, so avoid pointlessly installing it. llvm-svn: 107595
2010-07-05 05:44:19 +08:00
Record.push_back(Context.isInt128Installed());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(SPECIAL_TYPES, Record);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When writing a PCH file, write multiple type and declaration blocks as necessary and iterate until all types and declarations have been written. This reduces the Cocoa.h PCH file size by about 4% (since we don't write types we don't need), and fixes problems where writing a declaration generates a new type. This doesn't seem to have any impact on performance either way. llvm-svn: 70109
2009-04-26 11:49:13 +08:00
// Keep writing types and declarations until all types and
// declarations have been written.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EnterSubblock(DECLTYPES_BLOCK_ID, 3);
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
WriteDeclsBlockAbbrevs();
while (!DeclTypesToEmit.empty()) {
DeclOrType DOT = DeclTypesToEmit.front();
DeclTypesToEmit.pop();
if (DOT.isType())
WriteType(DOT.getType());
else
WriteDecl(Context, DOT.getDecl());
}
Stream.ExitBlock();
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Write the preprocessor block after we write out types + declarations, so that we catch any macros used within the declarations and types. Also, properly store a NULL selector. llvm-svn: 84334
2009-10-18 01:25:45 +08:00
WritePreprocessor(PP);
Incomplete promotion of selector info to per-file data. Store all selectors in the selector hash table instead of only those from the method pool. llvm-svn: 110158
2010-08-04 05:58:15 +08:00
WriteSelectors(SemaRef);
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
WriteReferencedSelectorsPool(SemaRef);
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
WriteIdentifierTable(PP);
Write the declaration and type offset arrays into the bitstream as blobs, so that we don't need to do any work to get these arrays into memory at PCH load time. This gives another 19% performance improvement to the Cocoa-prefixed "Hello, World!". llvm-svn: 70059
2009-04-26 02:35:21 +08:00
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
WriteTypeDeclOffsets();
Store the type ID for __builtin_va_list in the PCH file, so that the AST context's __builtin_va_list type will be set when the PCH file is loaded. This fixes the crash when CodeGen'ing a va_arg expression pulled in from a PCH file. llvm-svn: 69421
2009-04-18 13:55:16 +08:00
Support tentative definitions in precompiled headers. This isn't likely to happen (ever), but at least we'll do the right thing when it does. llvm-svn: 69829
2009-04-23 06:02:47 +08:00
// Write the record containing external, unnamed definitions.
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
if (!ExternalDefinitions.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions);
Support tentative definitions in precompiled headers. This isn't likely to happen (ever), but at least we'll do the right thing when it does. llvm-svn: 69829
2009-04-23 06:02:47 +08:00
// Write the record containing tentative definitions.
if (!TentativeDefinitions.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
// Write the record containing unused file scoped decls.
if (!UnusedFileScopedDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Support #pragma weak for PCH. llvm-svn: 110323
2010-08-05 17:48:08 +08:00
// Write the record containing weak undeclared identifiers.
if (!WeakUndeclaredIdentifiers.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
Support #pragma weak for PCH. llvm-svn: 110323
2010-08-05 17:48:08 +08:00
WeakUndeclaredIdentifiers);
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
// Write the record containing locally-scoped external definitions.
if (!LocallyScopedExternalDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS,
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
LocallyScopedExternalDecls);
Add Sema::ExtVectorDecls and Sema::ObjCCategoryImpls to the PCH file. Since these vectors are very, very rarely used and, when used in headers, and even when used are relatively small, we load them eagerly. llvm-svn: 70240
2009-04-28 04:06:05 +08:00
// Write the record containing ext_vector type names.
if (!ExtVectorDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
// Write the record containing VTable uses information.
if (!VTableUses.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(VTABLE_USES, VTableUses);
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
// Write the record containing dynamic classes declarations.
if (!DynamicClasses.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses);
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
Store the pending implicit instantiations in the PCH and perform them at the end of the translation unit that included the PCH, as God intended. llvm-svn: 110324
2010-08-05 17:48:16 +08:00
// Write the record containing pending implicit instantiations.
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
if (!PendingInstantiations.empty())
Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
Store the pending implicit instantiations in the PCH and perform them at the end of the translation unit that included the PCH, as God intended. llvm-svn: 110324
2010-08-05 17:48:16 +08:00
Read/write in PCH Sema's StdNamespace and StdBadAlloc and use a LazyDeclPtr for them that will deserialize them when needed. llvm-svn: 110031
2010-08-02 15:14:54 +08:00
// Write the record containing declaration references of Sema.
if (!SemaDeclRefs.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
Read/write in PCH Sema's StdNamespace and StdBadAlloc and use a LazyDeclPtr for them that will deserialize them when needed. llvm-svn: 110031
2010-08-02 15:14:54 +08:00
Keep track of the number of statements/expressions written to and read from a PCH file. It turns out that "Hello, World!" is bringing in 19% of all of the statements in Carbon.h, so we need to be lazy. llvm-svn: 69393
2009-04-18 06:13:46 +08:00
// Some simple statistics
Store the type ID for __builtin_va_list in the PCH file, so that the AST context's __builtin_va_list type will be set when the PCH file is loaded. This fixes the crash when CodeGen'ing a va_arg expression pulled in from a PCH file. llvm-svn: 69421
2009-04-18 13:55:16 +08:00
Record.clear();
Keep track of the number of statements/expressions written to and read from a PCH file. It turns out that "Hello, World!" is bringing in 19% of all of the statements in Carbon.h, so we need to be lazy. llvm-svn: 69393
2009-04-18 06:13:46 +08:00
Record.push_back(NumStatements);
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
Record.push_back(NumMacros);
Add PCH statistics for the number/percent of lexical/visible declcontexts read llvm-svn: 69835
2009-04-23 06:34:57 +08:00
Record.push_back(NumLexicalDeclContexts);
Record.push_back(NumVisibleDeclContexts);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(STATISTICS, Record);
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.ExitBlock();
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
const char *isysroot) {
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
using namespace llvm;
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
FirstDeclID += Chain->getTotalNumDecls();
FirstTypeID += Chain->getTotalNumTypes();
FirstIdentID += Chain->getTotalNumIdentifiers();
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
FirstSelectorID += Chain->getTotalNumSelectors();
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
FirstMacroID += Chain->getTotalNumMacroDefinitions();
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
NextDeclID = FirstDeclID;
NextTypeID = FirstTypeID;
NextIdentID = FirstIdentID;
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
NextSelectorID = FirstSelectorID;
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
NextMacroID = FirstMacroID;
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
ASTContext &Context = SemaRef.Context;
Preprocessor &PP = SemaRef.PP;
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EnterSubblock(AST_BLOCK_ID, 5);
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
WriteMetadata(Context, isysroot);
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
if (StatCalls && !isysroot)
WriteStatCache(*StatCalls);
// FIXME: Source manager block should only write new stuff, which could be
// done by tracking the largest ID in the chain
WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
// The special types are in the chained PCH.
// We don't start with the translation unit, but with its decls that
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// don't come from the chained PCH.
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
llvm::SmallVector<KindDeclIDPair, 64> NewGlobalDecls;
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
for (DeclContext::decl_iterator I = TU->noload_decls_begin(),
E = TU->noload_decls_end();
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
I != E; ++I) {
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
if ((*I)->getPCHLevel() == 0)
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I)));
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
else if ((*I)->isChangedSinceDeserialization())
(void)GetDeclRef(*I); // Make sure it's written, but don't record it.
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
}
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
// We also need to write a lexical updates block for the TU.
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv);
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(TU_UPDATE_LEXICAL);
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
reinterpret_cast<const char*>(NewGlobalDecls.data()),
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
NewGlobalDecls.size() * sizeof(KindDeclIDPair));
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
// And in C++, a visible updates block for the TU.
if (Context.getLangOptions().CPlusPlus) {
Abv = new llvm::BitCodeAbbrev();
Abv->Add(llvm::BitCodeAbbrevOp(UPDATE_VISIBLE));
Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::VBR, 6));
Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 32));
Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
UpdateVisibleAbbrev = Stream.EmitAbbrev(Abv);
WriteDeclContextVisibleUpdate(TU);
}
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Build a record containing all of the new tentative definitions in this
// file, in TentativeDefinitions order.
RecordData TentativeDefinitions;
for (unsigned i = 0, e = SemaRef.TentativeDefinitions.size(); i != e; ++i) {
if (SemaRef.TentativeDefinitions[i]->getPCHLevel() == 0)
AddDeclRef(SemaRef.TentativeDefinitions[i], TentativeDefinitions);
}
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
// Build a record containing all of the file scoped decls in this file.
RecordData UnusedFileScopedDecls;
for (unsigned i=0, e = SemaRef.UnusedFileScopedDecls.size(); i !=e; ++i) {
if (SemaRef.UnusedFileScopedDecls[i]->getPCHLevel() == 0)
AddDeclRef(SemaRef.UnusedFileScopedDecls[i], UnusedFileScopedDecls);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
}
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// We write the entire table, overwriting the tables from the chain.
RecordData WeakUndeclaredIdentifiers;
if (!SemaRef.WeakUndeclaredIdentifiers.empty()) {
WeakUndeclaredIdentifiers.push_back(
SemaRef.WeakUndeclaredIdentifiers.size());
for (llvm::DenseMap<IdentifierInfo*,Sema::WeakInfo>::iterator
I = SemaRef.WeakUndeclaredIdentifiers.begin(),
E = SemaRef.WeakUndeclaredIdentifiers.end(); I != E; ++I) {
AddIdentifierRef(I->first, WeakUndeclaredIdentifiers);
AddIdentifierRef(I->second.getAlias(), WeakUndeclaredIdentifiers);
AddSourceLocation(I->second.getLocation(), WeakUndeclaredIdentifiers);
WeakUndeclaredIdentifiers.push_back(I->second.getUsed());
}
}
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Build a record containing all of the locally-scoped external
// declarations in this header file. Generally, this record will be
// empty.
RecordData LocallyScopedExternalDecls;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// FIXME: This is filling in the AST file in densemap order which is
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// nondeterminstic!
for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
TD = SemaRef.LocallyScopedExternalDecls.begin(),
TDEnd = SemaRef.LocallyScopedExternalDecls.end();
TD != TDEnd; ++TD) {
if (TD->second->getPCHLevel() == 0)
AddDeclRef(TD->second, LocallyScopedExternalDecls);
}
// Build a record containing all of the ext_vector declarations.
RecordData ExtVectorDecls;
for (unsigned I = 0, N = SemaRef.ExtVectorDecls.size(); I != N; ++I) {
if (SemaRef.ExtVectorDecls[I]->getPCHLevel() == 0)
AddDeclRef(SemaRef.ExtVectorDecls[I], ExtVectorDecls);
}
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Build a record containing all of the VTable uses information.
// We write everything here, because it's too hard to determine whether
// a use is new to this part.
RecordData VTableUses;
if (!SemaRef.VTableUses.empty()) {
VTableUses.push_back(SemaRef.VTableUses.size());
for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
}
}
// Build a record containing all of dynamic classes declarations.
RecordData DynamicClasses;
for (unsigned I = 0, N = SemaRef.DynamicClasses.size(); I != N; ++I)
if (SemaRef.DynamicClasses[I]->getPCHLevel() == 0)
AddDeclRef(SemaRef.DynamicClasses[I], DynamicClasses);
// Build a record containing all of pending implicit instantiations.
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
RecordData PendingInstantiations;
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
for (std::deque<Sema::PendingImplicitInstantiation>::iterator
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
I = SemaRef.PendingInstantiations.begin(),
N = SemaRef.PendingInstantiations.end(); I != N; ++I) {
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
if (I->first->getPCHLevel() == 0) {
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
AddDeclRef(I->first, PendingInstantiations);
AddSourceLocation(I->second, PendingInstantiations);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
}
}
assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
"There are local ones at end of translation unit!");
// Build a record containing some declaration references.
// It's not worth the effort to avoid duplication here.
RecordData SemaDeclRefs;
if (SemaRef.StdNamespace || SemaRef.StdBadAlloc) {
AddDeclRef(SemaRef.getStdNamespace(), SemaDeclRefs);
AddDeclRef(SemaRef.getStdBadAlloc(), SemaDeclRefs);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EnterSubblock(DECLTYPES_BLOCK_ID, 3);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
WriteDeclsBlockAbbrevs();
while (!DeclTypesToEmit.empty()) {
DeclOrType DOT = DeclTypesToEmit.front();
DeclTypesToEmit.pop();
if (DOT.isType())
WriteType(DOT.getType());
else
WriteDecl(Context, DOT.getDecl());
}
Stream.ExitBlock();
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
WritePreprocessor(PP);
Activate selectors in chained PCH. Chained PCH now works for Objective-C. llvm-svn: 110262
2010-08-05 06:21:29 +08:00
WriteSelectors(SemaRef);
WriteReferencedSelectorsPool(SemaRef);
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
WriteIdentifierTable(PP);
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
WriteTypeDeclOffsets();
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
/// Build a record containing first declarations from a chained PCH and the
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// most recent declarations in this AST that they point to.
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
RecordData FirstLatestDeclIDs;
for (FirstLatestDeclMap::iterator
I = FirstLatestDecls.begin(), E = FirstLatestDecls.end(); I != E; ++I) {
assert(I->first->getPCHLevel() > I->second->getPCHLevel() &&
"Expected first & second to be in different PCHs");
AddDeclRef(I->first, FirstLatestDeclIDs);
AddDeclRef(I->second, FirstLatestDeclIDs);
}
if (!FirstLatestDeclIDs.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs);
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Write the record containing external, unnamed definitions.
if (!ExternalDefinitions.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Write the record containing tentative definitions.
if (!TentativeDefinitions.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
// Write the record containing unused file scoped decls.
if (!UnusedFileScopedDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing weak undeclared identifiers.
if (!WeakUndeclaredIdentifiers.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
WeakUndeclaredIdentifiers);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Write the record containing locally-scoped external definitions.
if (!LocallyScopedExternalDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS,
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
LocallyScopedExternalDecls);
// Write the record containing ext_vector type names.
if (!ExtVectorDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing VTable uses information.
if (!VTableUses.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(VTABLE_USES, VTableUses);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing dynamic classes declarations.
if (!DynamicClasses.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing pending implicit instantiations.
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
if (!PendingInstantiations.empty())
Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing declaration references of Sema.
if (!SemaDeclRefs.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
// Write the updates to C++ namespaces.
for (llvm::SmallPtrSet<const NamespaceDecl *, 16>::iterator
I = UpdatedNamespaces.begin(),
E = UpdatedNamespaces.end();
I != E; ++I)
WriteDeclContextVisibleUpdate(*I);
AST writer support for having specializations of templates from earlier in the chain. This ought to finish C++ chained PCH support. llvm-svn: 111986
2010-08-25 06:50:24 +08:00
// Write the updates to C++ template specialization lists.
if (!AdditionalTemplateSpecializations.empty())
WriteAdditionalTemplateSpecializations();
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Record.clear();
Record.push_back(NumStatements);
Record.push_back(NumMacros);
Record.push_back(NumLexicalDeclContexts);
Record.push_back(NumVisibleDeclContexts);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
WriteDeclUpdateBlock();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(STATISTICS, Record);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
Stream.ExitBlock();
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteDeclUpdateBlock() {
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
if (ReplacedDecls.empty())
return;
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
for (llvm::SmallVector<std::pair<DeclID, uint64_t>, 16>::iterator
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) {
Record.push_back(I->first);
Record.push_back(I->second);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(DECL_REPLACEMENTS, Record);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordData &Record) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Record.push_back(Loc.getRawEncoding());
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddSourceRange(SourceRange Range, RecordData &Record) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
AddSourceLocation(Range.getBegin(), Record);
AddSourceLocation(Range.getEnd(), Record);
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordData &Record) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Record.push_back(Value.getBitWidth());
Replace loops with SmallVector::append. llvm-svn: 113185
2010-09-07 07:43:28 +08:00
const uint64_t *Words = Value.getRawData();
Record.append(Words, Words + Value.getNumWords());
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordData &Record) {
Add PCH support for enumerations and enumerators. llvm-svn: 68974
2009-04-14 02:14:40 +08:00
Record.push_back(Value.isUnsigned());
AddAPInt(Value, Record);
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordData &Record) {
Add PCH support for PredefinedExpr and FloatingLiteral expressions llvm-svn: 69084
2009-04-15 05:55:33 +08:00
AddAPInt(Value.bitcastToAPInt(), Record);
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordData &Record) {
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
Record.push_back(getIdentifierRef(II));
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
if (II == 0)
return 0;
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID &ID = IdentifierIDs[II];
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
if (ID == 0)
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
ID = NextIdentID++;
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
return ID;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Macro definitions in AST files have their own IDs. llvm-svn: 114014
2010-09-16 03:54:06 +08:00
MacroID ASTWriter::getMacroDefinitionID(MacroDefinition *MD) {
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
if (MD == 0)
return 0;
Macro definitions in AST files have their own IDs. llvm-svn: 114014
2010-09-16 03:54:06 +08:00
MacroID &ID = MacroDefinitions[MD];
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
if (ID == 0)
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
ID = NextMacroID++;
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
return ID;
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddSelectorRef(const Selector SelRef, RecordData &Record) {
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
Record.push_back(getSelectorRef(SelRef));
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
SelectorID ASTWriter::getSelectorRef(Selector Sel) {
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
if (Sel.getAsOpaquePtr() == 0) {
return 0;
Add PCH read/write support for Objective-C Selectors. Note: This support is non-lazy. Once we get "Cocoa.h" humming, we can optimize this. llvm-svn: 69884
2009-04-23 18:39:46 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
SelectorID &SID = SelectorIDs[Sel];
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
if (SID == 0 && Chain) {
// This might trigger a ReadSelector callback, which will set the ID for
// this selector.
Chain->LoadSelector(Sel);
}
Add PCH read/write support for Objective-C Selectors. Note: This support is non-lazy. Once we get "Cocoa.h" humming, we can optimize this. llvm-svn: 69884
2009-04-23 18:39:46 +08:00
if (SID == 0) {
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
SID = NextSelectorID++;
Add PCH read/write support for Objective-C Selectors. Note: This support is non-lazy. Once we get "Cocoa.h" humming, we can optimize this. llvm-svn: 69884
2009-04-23 18:39:46 +08:00
}
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
return SID;
Add PCH read/write support for Objective-C Selectors. Note: This support is non-lazy. Once we get "Cocoa.h" humming, we can optimize this. llvm-svn: 69884
2009-04-23 18:39:46 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordData &Record) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
AddDeclRef(Temp->getDestructor(), Record);
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
const TemplateArgumentLocInfo &Arg,
RecordData &Record) {
switch (Kind) {
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
case TemplateArgument::Expression:
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
AddStmt(Arg.getAsExpr());
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
break;
case TemplateArgument::Type:
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
AddTypeSourceInfo(Arg.getAsTypeSourceInfo(), Record);
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
break;
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
case TemplateArgument::Template:
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
AddSourceRange(Arg.getTemplateQualifierRange(), Record);
AddSourceLocation(Arg.getTemplateNameLoc(), Record);
Introduce a new representation for template template parameters. Rather than storing them as either declarations (for the non-dependent case) or expressions (for the dependent case), we now (always) store them as TemplateNames. The primary change here is to add a new kind of TemplateArgument, which stores a TemplateName. However, making that change ripples to every switch on a TemplateArgument's kind, also affecting TemplateArgumentLocInfo/TemplateArgumentLoc, default template arguments for template template parameters, type-checking of template template arguments, etc. This change is light on testing. It should fix several pre-existing problems with template template parameters, such as: - the inability to use dependent template names as template template arguments - template template parameter default arguments cannot be instantiation However, there are enough pieces missing that more implementation is required before we can adequately test template template parameters. llvm-svn: 86777
2009-11-11 09:00:40 +08:00
break;
Track source information for template arguments and template specialization types. Preserve it through template instantiation. Preserve it through PCH, although TSTs themselves aren't serializable, so that's pretty much meaningless. llvm-svn: 85500
2009-10-29 16:12:44 +08:00
case TemplateArgument::Null:
case TemplateArgument::Integral:
case TemplateArgument::Declaration:
case TemplateArgument::Pack:
break;
}
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
RecordData &Record) {
AddTemplateArgument(Arg.getArgument(), Record);
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
bool InfoHasSameExpr
= Arg.getArgument().getAsExpr() == Arg.getLocInfo().getAsExpr();
Record.push_back(InfoHasSameExpr);
if (InfoHasSameExpr)
return; // Avoid storing the same expr twice.
}
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
AddTemplateArgumentLocInfo(Arg.getArgument().getKind(), Arg.getLocInfo(),
Record);
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordData &Record) {
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
if (TInfo == 0) {
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
AddTypeRef(QualType(), Record);
return;
}
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
AddTypeRef(TInfo->getType(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
TypeLocWriter TLW(*this, Record);
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
TLW.Visit(TL);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTypeRef(QualType T, RecordData &Record) {
Introduce ASTWriter::GetOrCreateTypeID and move most of the functionality of AddTypeRef there. No functionality change. llvm-svn: 111633
2010-08-21 00:04:14 +08:00
Record.push_back(GetOrCreateTypeID(T));
}
TypeID ASTWriter::GetOrCreateTypeID(QualType T) {
Refactoring; move the functionality of ASTWriter::GetOrCreateTypeID to the more generic MakeTypeID template function which accepts a type and a function object that returns a TypeIdx. MakeTypeID is in PCHCommon.h so that it can be used by ASTReader too. llvm-svn: 111634
2010-08-21 00:04:20 +08:00
return MakeTypeID(T,
std::bind1st(std::mem_fun(&ASTWriter::GetOrCreateTypeIdx), this));
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
TypeID ASTWriter::getTypeID(QualType T) const {
Refactoring; move the functionality of ASTWriter::GetOrCreateTypeID to the more generic MakeTypeID template function which accepts a type and a function object that returns a TypeIdx. MakeTypeID is in PCHCommon.h so that it can be used by ASTReader too. llvm-svn: 111634
2010-08-21 00:04:20 +08:00
return MakeTypeID(T,
std::bind1st(std::mem_fun(&ASTWriter::getTypeIdx), this));
A bit of refactoring; Introduce ASTWriter::GetOrCreateTypeIdx and move the emission of types there. No functionality change. llvm-svn: 111632
2010-08-21 00:04:09 +08:00
}
TypeIdx ASTWriter::GetOrCreateTypeIdx(QualType T) {
if (T.isNull())
return TypeIdx();
assert(!T.getLocalFastQualifiers());
Rename TypeIDs -> TypeIdxs. No functionality change. llvm-svn: 111631
2010-08-21 00:04:04 +08:00
TypeIdx &Idx = TypeIdxs[T];
serialization::TypeID is used with or without qualifiers, both as index and as index + qualifiers. Disambiguate and provide some type safety by using a new class TypeIdx for the "TypeID as index" semantics. llvm-svn: 111630
2010-08-21 00:03:59 +08:00
if (Idx.getIndex() == 0) {
When writing a PCH file, write multiple type and declaration blocks as necessary and iterate until all types and declarations have been written. This reduces the Cocoa.h PCH file size by about 4% (since we don't write types we don't need), and fixes problems where writing a declaration generates a new type. This doesn't seem to have any impact on performance either way. llvm-svn: 70109
2009-04-26 11:49:13 +08:00
// We haven't seen this type before. Assign it a new ID and put it
Refactor the representation of qualifiers to bring ExtQualType out of the Type hierarchy. Demote 'volatile' to extended-qualifier status. Audit our use of qualifiers and fix a few places that weren't dealing with qualifiers quite right; many more remain. llvm-svn: 82705
2009-09-25 03:53:00 +08:00
// into the queue of types to emit.
serialization::TypeID is used with or without qualifiers, both as index and as index + qualifiers. Disambiguate and provide some type safety by using a new class TypeIdx for the "TypeID as index" semantics. llvm-svn: 111630
2010-08-21 00:03:59 +08:00
Idx = TypeIdx(NextTypeID++);
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
DeclTypesToEmit.push(T);
When writing a PCH file, write multiple type and declaration blocks as necessary and iterate until all types and declarations have been written. This reduces the Cocoa.h PCH file size by about 4% (since we don't write types we don't need), and fixes problems where writing a declaration generates a new type. This doesn't seem to have any impact on performance either way. llvm-svn: 70109
2009-04-26 11:49:13 +08:00
}
A bit of refactoring; Introduce ASTWriter::GetOrCreateTypeIdx and move the emission of types there. No functionality change. llvm-svn: 111632
2010-08-21 00:04:09 +08:00
return Idx;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
TypeIdx ASTWriter::getTypeIdx(QualType T) const {
A bit of refactoring; Introduce ASTWriter::GetOrCreateTypeIdx and move the emission of types there. No functionality change. llvm-svn: 111632
2010-08-21 00:04:09 +08:00
if (T.isNull())
return TypeIdx();
assert(!T.getLocalFastQualifiers());
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
TypeIdxMap::const_iterator I = TypeIdxs.find(T);
assert(I != TypeIdxs.end() && "Type not emitted!");
return I->second;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddDeclRef(const Decl *D, RecordData &Record) {
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
Record.push_back(GetDeclRef(D));
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DeclID ASTWriter::GetDeclRef(const Decl *D) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
if (D == 0) {
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
return 0;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Fix a marvelous chained AST writing bug, where we end up with the following amusing sequence: - AST writing schedules writing a type X* that it had never seen before - AST writing starts writing another declaration, ends up deserializing X* from a prior AST file. Now we have two type IDs for the same type! - AST writer tries to write X*. It only has the lower-numbered ID from the the prior AST file, so references to the higher-numbered ID that was scheduled for writing go off into lalaland. To fix this, keep the higher-numbered ID so we end up writing the type twice. Since this issue occurs so rarely, and type records are generally rather small, I deemed this better than the alternative: to keep a separate mapping from the higher-numbered IDs to the lower-numbered IDs, which we would end up having to check whenever we want to deserialize any type. Fixes <rdar://problem/8511624>, I think. llvm-svn: 115647
2010-10-06 02:37:06 +08:00
assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DeclID &ID = DeclIDs[D];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (ID == 0) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// We haven't seen this declaration before. Give it a new ID and
// enqueue it in the list of declarations to emit.
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
ID = NextDeclID++;
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
DeclTypesToEmit.push(const_cast<Decl *>(D));
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
} else if (ID < FirstDeclID && D->isChangedSinceDeserialization()) {
// We don't add it to the replacement collection here, because we don't
// have the offset yet.
DeclTypesToEmit.push(const_cast<Decl *>(D));
// Reset the flag, so that we don't add this decl multiple times.
const_cast<Decl *>(D)->setChangedSinceDeserialization(false);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
return ID;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DeclID ASTWriter::getDeclID(const Decl *D) {
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
if (D == 0)
return 0;
assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
return DeclIDs[D];
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddDeclarationName(DeclarationName Name, RecordData &Record) {
add an abbreviation for common PARM_VAR_DECL. All but 9 of the parm var decls in leopard cocoa.h end up using this abbreviation, which shrinks the bitcode file by about 50K: 7217736->7167120. Before: Block ID #12 (DECLS_BLOCK): Num Instances: 1 Total Size: 2.23595e+07b/2.79494e+06B/698736W % of file: 38.7233 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 139387 % Abbrev Recs: 0 After: Block ID #12 (DECLS_BLOCK): Num Instances: 1 Total Size: 2.02405e+07b/2.53006e+06B/632516W % of file: 35.301 Num SubBlocks: 0 Num Abbrevs: 1 Num Records: 139387 % Abbrev Recs: 19.2902 llvm-svn: 70199
2009-04-27 15:35:58 +08:00
// FIXME: Emit a stable enum for NameKind. 0 = Identifier etc.
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Record.push_back(Name.getNameKind());
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
AddIdentifierRef(Name.getAsIdentifierInfo(), Record);
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Add PCH read/write support for Objective-C Selectors. Note: This support is non-lazy. Once we get "Cocoa.h" humming, we can optimize this. llvm-svn: 69884
2009-04-23 18:39:46 +08:00
AddSelectorRef(Name.getObjCSelector(), Record);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
AddTypeRef(Name.getCXXNameType(), Record);
break;
case DeclarationName::CXXOperatorName:
Record.push_back(Name.getCXXOverloadedOperator());
break;
Add DeclarationName support for C++0x operator literals. They should now work as function names outside of templates - they'll probably cause some damage there as they're largely untested. llvm-svn: 90064
2009-11-29 15:34:05 +08:00
case DeclarationName::CXXLiteralOperatorName:
AddIdentifierRef(Name.getCXXLiteralIdentifier(), Record);
break;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
case DeclarationName::CXXUsingDirective:
// No extra data to emit
break;
}
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ASTWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
DeclarationName Name, RecordData &Record) {
switch (Name.getNameKind()) {
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
AddTypeSourceInfo(DNLoc.NamedType.TInfo, Record);
break;
case DeclarationName::CXXOperatorName:
AddSourceLocation(
SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.BeginOpNameLoc),
Record);
AddSourceLocation(
SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc),
Record);
break;
case DeclarationName::CXXLiteralOperatorName:
AddSourceLocation(
SourceLocation::getFromRawEncoding(DNLoc.CXXLiteralOperatorName.OpNameLoc),
Record);
break;
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXUsingDirective:
break;
}
}
void ASTWriter::AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
RecordData &Record) {
AddDeclarationName(NameInfo.getName(), Record);
AddSourceLocation(NameInfo.getLoc(), Record);
AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
}
void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
RecordData &Record) {
AddNestedNameSpecifier(Info.NNS, Record);
AddSourceRange(Info.NNSRange, Record);
Record.push_back(Info.NumTemplParamLists);
for (unsigned i=0, e=Info.NumTemplParamLists; i != e; ++i)
AddTemplateParameterList(Info.TemplParamLists[i], Record);
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
RecordData &Record) {
// Nested name specifiers usually aren't too long. I think that 8 would
// typically accomodate the vast majority.
llvm::SmallVector<NestedNameSpecifier *, 8> NestedNames;
// Push each of the NNS's onto a stack for serialization in reverse order.
while (NNS) {
NestedNames.push_back(NNS);
NNS = NNS->getPrefix();
}
Record.push_back(NestedNames.size());
while(!NestedNames.empty()) {
NNS = NestedNames.pop_back_val();
NestedNameSpecifier::SpecifierKind Kind = NNS->getKind();
Record.push_back(Kind);
switch (Kind) {
case NestedNameSpecifier::Identifier:
AddIdentifierRef(NNS->getAsIdentifier(), Record);
break;
case NestedNameSpecifier::Namespace:
AddDeclRef(NNS->getAsNamespace(), Record);
break;
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
AddTypeRef(QualType(NNS->getAsType(), 0), Record);
Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
break;
case NestedNameSpecifier::Global:
// Don't need to write an associated value.
break;
}
}
}
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTemplateName(TemplateName Name, RecordData &Record) {
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
TemplateName::NameKind Kind = Name.getKind();
Record.push_back(Kind);
switch (Kind) {
case TemplateName::Template:
AddDeclRef(Name.getAsTemplateDecl(), Record);
break;
case TemplateName::OverloadedTemplate: {
OverloadedTemplateStorage *OvT = Name.getAsOverloadedTemplate();
Record.push_back(OvT->size());
for (OverloadedTemplateStorage::iterator I = OvT->begin(), E = OvT->end();
I != E; ++I)
AddDeclRef(*I, Record);
break;
}
case TemplateName::QualifiedTemplate: {
QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
AddNestedNameSpecifier(QualT->getQualifier(), Record);
Record.push_back(QualT->hasTemplateKeyword());
AddDeclRef(QualT->getTemplateDecl(), Record);
break;
}
case TemplateName::DependentTemplate: {
DependentTemplateName *DepT = Name.getAsDependentTemplateName();
AddNestedNameSpecifier(DepT->getQualifier(), Record);
Record.push_back(DepT->isIdentifier());
if (DepT->isIdentifier())
AddIdentifierRef(DepT->getIdentifier(), Record);
else
Record.push_back(DepT->getOperator());
break;
}
}
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
RecordData &Record) {
Record.push_back(Arg.getKind());
switch (Arg.getKind()) {
case TemplateArgument::Null:
break;
case TemplateArgument::Type:
AddTypeRef(Arg.getAsType(), Record);
break;
case TemplateArgument::Declaration:
AddDeclRef(Arg.getAsDecl(), Record);
break;
case TemplateArgument::Integral:
AddAPSInt(*Arg.getAsIntegral(), Record);
AddTypeRef(Arg.getIntegralType(), Record);
break;
case TemplateArgument::Template:
AddTemplateName(Arg.getAsTemplate(), Record);
break;
case TemplateArgument::Expression:
AddStmt(Arg.getAsExpr());
break;
case TemplateArgument::Pack:
Record.push_back(Arg.pack_size());
for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end();
I != E; ++I)
AddTemplateArgument(*I, Record);
break;
}
}
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
void
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
RecordData &Record) {
assert(TemplateParams && "No TemplateParams!");
AddSourceLocation(TemplateParams->getTemplateLoc(), Record);
AddSourceLocation(TemplateParams->getLAngleLoc(), Record);
AddSourceLocation(TemplateParams->getRAngleLoc(), Record);
Record.push_back(TemplateParams->size());
for (TemplateParameterList::const_iterator
P = TemplateParams->begin(), PEnd = TemplateParams->end();
P != PEnd; ++P)
AddDeclRef(*P, Record);
}
/// \brief Emit a template argument list.
void
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
RecordData &Record) {
assert(TemplateArgs && "No TemplateArgs!");
Record.push_back(TemplateArgs->flat_size());
for (int i=0, e = TemplateArgs->flat_size(); i != e; ++i)
AddTemplateArgument(TemplateArgs->get(i), Record);
}
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
void
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordData &Record) {
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
Record.push_back(Set.size());
for (UnresolvedSetImpl::const_iterator
I = Set.begin(), E = Set.end(); I != E; ++I) {
AddDeclRef(I.getDecl(), Record);
Record.push_back(I.getAccess());
}
}
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
RecordData &Record) {
Record.push_back(Base.isVirtual());
Record.push_back(Base.isBaseOfClass());
Record.push_back(Base.getAccessSpecifierAsWritten());
Add source location information to C++ base specifiers. llvm-svn: 109396
2010-07-27 00:56:01 +08:00
AddTypeSourceInfo(Base.getTypeSourceInfo(), Record);
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
AddSourceRange(Base.getSourceRange(), Record);
}
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddCXXBaseOrMemberInitializers(
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
const CXXBaseOrMemberInitializer * const *BaseOrMembers,
unsigned NumBaseOrMembers, RecordData &Record) {
Record.push_back(NumBaseOrMembers);
for (unsigned i=0; i != NumBaseOrMembers; ++i) {
const CXXBaseOrMemberInitializer *Init = BaseOrMembers[i];
Record.push_back(Init->isBaseInitializer());
if (Init->isBaseInitializer()) {
AddTypeSourceInfo(Init->getBaseClassInfo(), Record);
Record.push_back(Init->isBaseVirtual());
} else {
AddDeclRef(Init->getMember(), Record);
}
AddSourceLocation(Init->getMemberLocation(), Record);
AddStmt(Init->getInit());
AddDeclRef(Init->getAnonUnionMember(), Record);
AddSourceLocation(Init->getLParenLoc(), Record);
AddSourceLocation(Init->getRParenLoc(), Record);
Record.push_back(Init->isWritten());
if (Init->isWritten()) {
Record.push_back(Init->getSourceOrder());
} else {
Record.push_back(Init->getNumArrayIndices());
for (unsigned i=0, e=Init->getNumArrayIndices(); i != e; ++i)
AddDeclRef(Init->getArrayIndex(i), Record);
}
}
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTWriter::SetReader(ASTReader *Reader) {
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
assert(Reader && "Cannot remove chain");
assert(FirstDeclID == NextDeclID &&
FirstTypeID == NextTypeID &&
FirstIdentID == NextIdentID &&
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
FirstSelectorID == NextSelectorID &&
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
FirstMacroID == NextMacroID &&
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
"Setting chain after writing has started.");
Chain = Reader;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
void ASTWriter::IdentifierRead(IdentID ID, IdentifierInfo *II) {
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
IdentifierIDs[II] = ID;
}
serialization::TypeID is used with or without qualifiers, both as index and as index + qualifiers. Disambiguate and provide some type safety by using a new class TypeIdx for the "TypeID as index" semantics. llvm-svn: 111630
2010-08-21 00:03:59 +08:00
void ASTWriter::TypeRead(TypeIdx Idx, QualType T) {
Fix a marvelous chained AST writing bug, where we end up with the following amusing sequence: - AST writing schedules writing a type X* that it had never seen before - AST writing starts writing another declaration, ends up deserializing X* from a prior AST file. Now we have two type IDs for the same type! - AST writer tries to write X*. It only has the lower-numbered ID from the the prior AST file, so references to the higher-numbered ID that was scheduled for writing go off into lalaland. To fix this, keep the higher-numbered ID so we end up writing the type twice. Since this issue occurs so rarely, and type records are generally rather small, I deemed this better than the alternative: to keep a separate mapping from the higher-numbered IDs to the lower-numbered IDs, which we would end up having to check whenever we want to deserialize any type. Fixes <rdar://problem/8511624>, I think. llvm-svn: 115647
2010-10-06 02:37:06 +08:00
// Always take the highest-numbered type index. This copes with an interesting
// case for chained AST writing where we schedule writing the type and then,
// later, deserialize the type from another AST. In this case, we want to
// keep the higher-numbered entry so that we can properly write it out to
// the AST file.
TypeIdx &StoredIdx = TypeIdxs[T];
if (Idx.getIndex() >= StoredIdx.getIndex())
StoredIdx = Idx;
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
void ASTWriter::DeclRead(DeclID ID, const Decl *D) {
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
DeclIDs[D] = ID;
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
}
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
void ASTWriter::SelectorRead(SelectorID ID, Selector S) {
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
SelectorIDs[S] = ID;
}
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
void ASTWriter::MacroDefinitionRead(serialization::MacroID ID,
MacroDefinition *MD) {
MacroDefinitions[MD] = ID;
}