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

4834 lines
174 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"
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
#include "clang/AST/DeclFriend.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"
(De-)serialize header search options. llvm-svn: 166586
2012-10-25 00:50:34 +08:00
#include "clang/Lex/HeaderSearchOptions.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"
(De-)serialize the preprocessor options, including macros defined, -include'd files, etc. llvm-svn: 166614
2012-10-25 04:05:57 +08:00
#include "clang/Lex/PreprocessorOptions.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"
rework the stat cache, pulling it out of FileManager.h into its own header and giving it some more structure. No functionality change. llvm-svn: 120030
2010-11-24 03:19:34 +08:00
#include "clang/Basic/FileSystemStatCache.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"
Serialize TargetOptions into an AST file, and make sure that we keep target options around so they can be accessed at any point (rather than keeping them transient). llvm-svn: 166072
2012-10-17 07:40:58 +08:00
#include "clang/Basic/TargetOptions.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"
Implement a new 'availability' attribute, that allows one to specify which versions of an OS provide a certain facility. For example, void foo() __attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6))); says that the function "foo" was introduced in 10.2, deprecated in 10.4, and completely obsoleted in 10.6. This attribute ties in with the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that we want to deploy back to Mac OS X 10.1). There are several concrete behaviors that this attribute enables, as illustrated with the function foo() above: - If we choose a deployment target >= Mac OS X 10.4, uses of "foo" will result in a deprecation warning, as if we had placed attribute((deprecated)) on it (but with a better diagnostic) - If we choose a deployment target >= Mac OS X 10.6, uses of "foo" will result in an "unavailable" warning (in C)/error (in C++), as if we had placed attribute((unavailable)) on it - If we choose a deployment target prior to 10.2, foo() is weak-imported (if it is a kind of entity that can be weak imported), as if we had placed the weak_import attribute on it. Naturally, there can be multiple availability attributes on a declaration, for different platforms; only the current platform matters when checking availability attributes. The only platforms this attribute currently works for are "ios" and "macosx", since we already have -mxxxx-version-min flags for them and we have experience there with macro tricks translating down to the deprecated/unavailable/weak_import attributes. The end goal is to open this up to other platforms, and even extension to other "platforms" that are really libraries (say, through a #pragma clang define_system), but that hasn't yet been designed and we may want to shake out more issues with this narrower problem first. Addresses <rdar://problem/6690412>. As a drive-by bug-fix, if an entity is both deprecated and unavailable, we only emit the "unavailable" diagnostic. llvm-svn: 128127
2011-03-23 08:50:03 +08:00
#include "clang/Basic/VersionTuple.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"
Replace all uses of PathV1::makeAbsolute with PathV2::fs::make_absolute. llvm-svn: 122340
2010-12-22 00:45:57 +08:00
#include "llvm/Support/FileSystem.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"
Merge System into Support. llvm-svn: 120297
2010-11-30 02:12:39 +08:00
#include "llvm/Support/Path.h"
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
#include <algorithm>
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>
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
#include <string.h>
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
#include <utility>
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>
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
static StringRef data(const std::vector<T, Allocator> &v) {
if (v.empty()) return StringRef();
return StringRef(reinterpret_cast<const char*>(&v[0]),
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
sizeof(T) * v.size());
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +08:00
}
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
template <typename T>
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
static StringRef data(const SmallVectorImpl<T> &v) {
return StringRef(reinterpret_cast<const char*>(v.data()),
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
sizeof(T) * v.size());
Safely get a data pointer for vectors that might be empty. llvm-svn: 109867
2010-07-31 01:03:48 +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
//===----------------------------------------------------------------------===//
// 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;
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTWriter::RecordDataImpl &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
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTTypeWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &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) {
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Built-in types are never serialized");
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::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) {
Fix AST serialization of reference-to-reference types. This previously caused a crash when deserializing the AST for this: typedef char (&R); extern R &r; llvm-svn: 129358
2011-04-12 18:38:03 +08:00
Writer.AddTypeRef(T->getPointeeTypeAsWritten(), Record);
Record.push_back(T->isSpelledAsLValue());
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) {
Fix AST serialization of reference-to-reference types. This previously caused a crash when deserializing the AST for this: typedef char (&R); extern R &r; llvm-svn: 129358
2011-04-12 18:38:03 +08:00
Writer.AddTypeRef(T->getPointeeTypeAsWritten(), 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());
Add a variant of GCC-style vector types for ARM NEON. NEON vector types need to be mangled in a special way to comply with ARM's ABI, similar to some of the AltiVec-specific vector types. This patch is mostly just renaming a bunch of "AltiVecSpecific" things, since they will no longer be specific to AltiVec. Besides that, it just adds the new "NeonVector" enum. llvm-svn: 118724
2010-11-11 05:56:12 +08:00
Record.push_back(T->getVectorKind());
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());
PR8369: make __attribute((regparm(0))) work correctly. Original patch by pageexec@freemail.hu, tweaks by me. llvm-svn: 129206
2011-04-09 16:18:08 +08:00
Record.push_back(C.getHasRegParm());
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());
Automatic Reference Counting. Language-design credit goes to a lot of people, but I particularly want to single out Blaine Garst and Patrick Beard for their contributions. Compiler implementation credit goes to Argyrios, Doug, Fariborz, and myself, in no particular order. llvm-svn: 133103
2011-06-16 07:02:42 +08:00
Record.push_back(C.getProducesResult());
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());
Track whether a function type has a trailing return type as type sugar. Use this to pretty-print such function types better, and to fix a case where we were not instantiating templates in lexical order. In passing, move the Variadic bit from Type's bitfields to FunctionProtoType to get the Type bitfields down to 32 bits. Also ensure that we always substitute the return type of a function when substituting explicitly-specified arguments, since that can cause us to bail out with a SFINAE error before we hit a hard error in parameter substitution. llvm-svn: 150241
2012-02-10 17:58:53 +08:00
Record.push_back(T->hasTrailingReturn());
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->getTypeQuals());
Rvalue references for *this: - Add ref-qualifiers to the type system; they are part of the canonical type. Print & profile ref-qualifiers - Translate the ref-qualifier from the Declarator chunk for functions to the function type. - Diagnose mis-uses of ref-qualifiers w.r.t. static member functions, free functions, constructors, destructors, etc. - Add serialization and deserialization of ref-qualifiers. llvm-svn: 124281
2011-01-26 13:01:58 +08:00
Record.push_back(static_cast<unsigned>(T->getRefQualifier()));
Propagate the new exception information to FunctionProtoType. Change the interface to expose the new information and deal with the enormous fallout. Introduce the new ExceptionSpecificationType value EST_DynamicNone to more easily deal with empty throw specifications. Update the tests for noexcept and fix the various bugs uncovered, such as lack of tentative parsing support. llvm-svn: 127537
2011-03-12 19:50:43 +08:00
Record.push_back(T->getExceptionSpecType());
if (T->getExceptionSpecType() == EST_Dynamic) {
Record.push_back(T->getNumExceptions());
for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I)
Writer.AddTypeRef(T->getExceptionType(I), Record);
} else if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
Writer.AddStmt(T->getNoexceptExpr());
Fix serialization of uninstantiated exception specifications. Patch by Li Kan, test by me. llvm-svn: 155289
2012-04-22 01:47:47 +08:00
} else if (T->getExceptionSpecType() == EST_Uninstantiated) {
Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
Writer.AddDeclRef(T->getExceptionSpecTemplate(), Record);
Final piece of core issue 1330: delay computing the exception specification of a defaulted special member function until the exception specification is needed (using the same criteria used for the delayed instantiation of exception specifications for function temploids). EST_Delayed is now EST_Unevaluated (using 1330's terminology), and, like EST_Uninstantiated, carries a pointer to the FunctionDecl which will be used to resolve the exception specification. This is enabled for all C++ modes: it's a little faster in the case where the exception specification isn't used, allows our C++11-in-C++98 extensions to work, and is still correct for C++98, since in that mode the computation of the exception specification can't fail. The diagnostics here aren't great (in particular, we should include implicit evaluation of exception specifications for defaulted special members in the template instantiation backtraces), but they're not much worse than before. Our approach to the problem of cycles between in-class initializers and the exception specification for a defaulted default constructor is modified a little by this change -- we now reject any odr-use of a defaulted default constructor if that constructor uses an in-class initializer and the use is in an in-class initialzer which is declared lexically earlier. This is a closer approximation to the current draft solution in core issue 1351, but isn't an exact match (but the current draft wording isn't reasonable, so that's to be expected). llvm-svn: 160847
2012-07-27 12:22:15 +08:00
} else if (T->getExceptionSpecType() == EST_Unevaluated) {
Writer.AddDeclRef(T->getExceptionSpecDecl(), Record);
Propagate the new exception information to FunctionProtoType. Change the interface to expose the new information and deal with the enormous fallout. Introduce the new ExceptionSpecificationType value EST_DynamicNone to more easily deal with empty throw specifications. Update the tests for noexcept and fix the various bugs uncovered, such as lack of tentative parsing support. llvm-svn: 127537
2011-03-12 19:50:43 +08:00
}
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) {
Within the body of a lambda expression, decltype((x)) for an id-expression 'x' will compute the type based on the assumption that 'x' will be captured, even if it isn't captured, per C++11 [expr.prim.lambda]p18. There are two related refactors that go into implementing this: 1) Split out the check that determines whether we should capture a particular variable reference, along with the computation of the type of the field, from the actual act of capturing the variable. 2) Always compute the result of decltype() within Sema, rather than AST, because the decltype() computation is now context-sensitive. llvm-svn: 150347
2012-02-13 02:42:33 +08:00
Writer.AddTypeRef(T->getUnderlyingType(), Record);
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
}
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
Writer.AddTypeRef(T->getBaseType(), Record);
Writer.AddTypeRef(T->getUnderlyingType(), Record);
Record.push_back(T->getUTTKind());
Code = TYPE_UNARY_TRANSFORM;
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
void ASTTypeWriter::VisitAutoType(const AutoType *T) {
Writer.AddTypeRef(T->getDeducedType(), Record);
Code = TYPE_AUTO;
}
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());
Rework the way in which we (de-)serialize the declarations corresponding to TagType and ObjCInterfaceType. Previously, we would serialize the definition (if available) or the canonical declaration (if no definition was available). However, this can end up forcing the deserialization of the definition even through we might not want to yet. Instead, always serialize the canonical declaration reference in the TagType/ObjCInterfaceType entry, and as part of loading a pending definition, update the "decl" pointer within the type node to point at the definition. This is more robust in hard-to-isolate cases where the *Type gets built and filled in before we see the definition. llvm-svn: 148323
2012-01-18 03:21:53 +08:00
Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), 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
}
Introduce an AttributedType, but don't actually use it anywhere yet. The initial TreeTransform is a cop-out, but it's more-or-less equivalent to what we were doing before, or rather what we're doing now and might eventually stop doing in favor of using this type. I am simultaneously intrigued by the possibilities of rebuilding a dependent Attri llvm-svn: 122942
2011-01-06 09:58:22 +08:00
void ASTTypeWriter::VisitAttributedType(const AttributedType *T) {
Writer.AddTypeRef(T->getModifiedType(), Record);
Writer.AddTypeRef(T->getEquivalentType(), Record);
Record.push_back(T->getAttrKind());
Code = TYPE_ATTRIBUTED;
}
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
}
Start implementing support for substitution into pack expansions that involve template parameter packs at multiple template levels that occur within the signatures members of class templates (and partial specializations thereof). This is a work-in-progress that is deficient in several ways, notably: - It only works for template type parameter packs, but we need to also support non-type template parameter packs and template template parameter packs. - It doesn't keep track of the lengths of the substituted argument packs in the expansion, so it can't properly diagnose length mismatches. However, this is a concrete step in the right direction. llvm-svn: 123425
2011-01-14 10:55:32 +08:00
void
ASTTypeWriter::VisitSubstTemplateTypeParmPackType(
const SubstTemplateTypeParmPackType *T) {
Writer.AddTypeRef(QualType(T->getReplacedParameter(), 0), Record);
Writer.AddTemplateArgument(T->getArgumentPack(), Record);
Code = TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK;
}
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);
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
Writer.AddTypeRef(T->isTypeAlias() ? T->getAliasedType() :
T->isCanonicalUnqualified() ? QualType()
- 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
: 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)
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Cannot serialize dependent sized extended vector types");
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::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());
Re-applies the patch first applied way back in r106099, with accompanying fixes to make it work today. The core of this patch is to provide a link from a TemplateTypeParmType back to the TemplateTypeParmDecl node which declared it. This in turn provides much more precise information about the type, where it came from, and how it functions for AST consumers. To make the patch work almost a year after its first attempt, it needed serialization support, and it now retains the old getName() interface. Finally, it requires us to not attempt to instantiate the type in an unsupported friend decl -- specifically those coming from template friend decls but which refer to a specific type through a dependent name. A cleaner representation of the last item would be to build FriendTemplateDecl nodes for these, storing their template parameters etc, and to perform proper instantation of them like any other template declaration. They can still be flagged as unsupported for the purpose of access checking, etc. This passed an asserts-enabled bootstrap for me, and the reduced test case mentioned in the original review thread no longer causes issues, likely fixed at somewhere amidst the 24k revisions that have elapsed. llvm-svn: 130628
2011-05-01 08:51:33 +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_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
}
Introduce a new type, PackExpansionType, to capture types that are pack expansions, e.g. given template<typename... Types> struct tuple; template<typename... Types> struct tuple_of_refs { typedef tuple<Types&...> types; }; the type of the "types" typedef is a PackExpansionType whose pattern is Types&. This commit introduces support for creating pack expansions for template type arguments, as above, but not for any other kind of pack expansion, nor for any form of instantiation. llvm-svn: 122223
2010-12-20 10:24:11 +08:00
void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
Writer.AddTypeRef(T->getPattern(), Record);
Keep track of the number of expansions to be produced from a type pack expansion, when it is known due to the substitution of an out parameter pack. This allows us to properly handle substitution into pack expansions that involve multiple parameter packs at different template parameter levels, even when this substitution happens one level at a time (as with partial specializations of member class templates and the signatures of member function templates). Note that the diagnostic we provide when there is an arity mismatch between an outer parameter pack and an inner parameter pack in this case isn't as clear as the normal diagnostic for an arity mismatch. However, this doesn't matter because these cases are very, very rare and (even then) only typically occur in a SFINAE context. The other kinds of pack expansions (expression, template, etc.) still need to support optional tracking of the number of expansions, and we need the moral equivalent of SubstTemplateTypeParmPackType for substituted argument packs of template template and non-type template parameters. llvm-svn: 123448
2011-01-15 01:04:44 +08:00
if (llvm::Optional<unsigned> NumExpansions = T->getNumExpansions())
Record.push_back(*NumExpansions + 1);
else
Record.push_back(0);
Introduce a new type, PackExpansionType, to capture types that are pack expansions, e.g. given template<typename... Types> struct tuple; template<typename... Types> struct tuple_of_refs { typedef tuple<Types&...> types; }; the type of the "types" typedef is a PackExpansionType whose pattern is Types&. This commit introduces support for creating pack expansions for template type arguments, as above, but not for any other kind of pack expansion, nor for any form of instantiation. llvm-svn: 122223
2010-12-20 10:24:11 +08:00
Code = TYPE_PACK_EXPANSION;
}
Added ParenType type node. llvm-svn: 121488
2010-12-11 00:29:40 +08:00
void ASTTypeWriter::VisitParenType(const ParenType *T) {
Writer.AddTypeRef(T->getInnerType(), Record);
Code = TYPE_PAREN;
}
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) {
Canonicalize the declaration we write to a PCH file for an InjectedClassNameType; otherwise, it won't be properly wired to the original (canonical) declaration when it is deserialized. Fixes <rdar://problem/11112464>. llvm-svn: 153442
2012-03-26 23:52:37 +08:00
Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), 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) {
Rework the way in which we (de-)serialize the declarations corresponding to TagType and ObjCInterfaceType. Previously, we would serialize the definition (if available) or the canonical declaration (if no definition was available). However, this can end up forcing the deserialization of the definition even through we might not want to yet. Instead, always serialize the canonical declaration reference in the TagType/ObjCInterfaceType entry, and as part of loading a pending definition, update the "decl" pointer within the type node to point at the definition. This is more robust in hard-to-isolate cases where the *Type gets built and filled in before we see the definition. llvm-svn: 148323
2012-01-18 03:21:53 +08:00
Writer.AddDeclRef(T->getDecl()->getCanonicalDecl(), 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
}
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
void
ASTTypeWriter::VisitAtomicType(const AtomicType *T) {
Writer.AddTypeRef(T->getValueType(), Record);
Code = TYPE_ATOMIC;
}
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;
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTWriter::RecordDataImpl &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:
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &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);
Improved MemberPointerType source locations. llvm-svn: 127085
2011-03-05 22:42:21 +08:00
Writer.AddTypeSourceInfo(TL.getClassTInfo(), 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::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) {
Forgotten part of previous commit. llvm-svn: 127536
2011-03-12 19:17:06 +08:00
Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
Fixed FunctionTypeLoc source range. llvm-svn: 165259
2012-10-05 05:42:10 +08:00
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Forgotten part of previous commit. llvm-svn: 127536
2011-03-12 19:17:06 +08:00
Writer.AddSourceLocation(TL.getLocalRangeEnd(), 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
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
}
Implement a new type node, UnaryTransformType, designed to represent a type that turns one type into another. This is used as the basis to implement __underlying_type properly - with TypeSourceInfo and proper behavior in the face of templates. llvm-svn: 132017
2011-05-25 06:41:36 +08:00
void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
Writer.AddSourceLocation(TL.getKWLoc(), Record);
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
}
Implement the C++0x deduced 'auto' feature. This fixes PR 8738, 9060 and 9132. llvm-svn: 126069
2011-02-20 11:19:35 +08:00
void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc 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::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
}
Introduce an AttributedType, but don't actually use it anywhere yet. The initial TreeTransform is a cop-out, but it's more-or-less equivalent to what we were doing before, or rather what we're doing now and might eventually stop doing in favor of using this type. I am simultaneously intrigued by the possibilities of rebuilding a dependent Attri llvm-svn: 122942
2011-01-06 09:58:22 +08:00
void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
if (TL.hasAttrOperand()) {
SourceRange range = TL.getAttrOperandParensRange();
Writer.AddSourceLocation(range.getBegin(), Record);
Writer.AddSourceLocation(range.getEnd(), Record);
}
if (TL.hasAttrExprOperand()) {
Expr *operand = TL.getAttrExprOperand();
Record.push_back(operand ? 1 : 0);
if (operand) Writer.AddStmt(operand);
} else if (TL.hasAttrEnumOperand()) {
Writer.AddSourceLocation(TL.getAttrEnumOperandLoc(), 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::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);
}
Start implementing support for substitution into pack expansions that involve template parameter packs at multiple template levels that occur within the signatures members of class templates (and partial specializations thereof). This is a work-in-progress that is deficient in several ways, notably: - It only works for template type parameter packs, but we need to also support non-type template parameter packs and template template parameter packs. - It doesn't keep track of the lengths of the substituted argument packs in the expansion, so it can't properly diagnose length mismatches. However, this is a concrete step in the right direction. llvm-svn: 123425
2011-01-14 10:55:32 +08:00
void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
SubstTemplateTypeParmPackTypeLoc 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) {
Added location for template keyword in TemplateSpecializationTypeLoc. In the process removed some naming ambiguities. llvm-svn: 149870
2012-02-06 22:41:24 +08:00
Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), 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
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
}
Added ParenType type node. llvm-svn: 121488
2010-12-11 00:29:40 +08:00
void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
}
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Removed redundant location info from ElaboratedTypeLoc / DependentNameLoc / DependentTSTLoc. Uniformed names referencing elaborated keyword. No intended functionality changes. llvm-svn: 149889
2012-02-07 03:09:27 +08:00
Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
Reinstate the introduction of source-location information for nested-name-speciciers within elaborated type names, e.g., enum clang::NestedNameSpecifier::SpecifierKind Fixes in this iteration include: (1) Compute the type-source range properly for a dependent template specialization type that starts with "template template-id ::", as in a member access expression dep->template f<T>::f() This is a latent bug I triggered with this change (because now we're checking the computed source ranges for dependent template specialization types). But the real problem was... (2) Make sure to set the qualifier range on a dependent template specialization type appropriately. This will go away once we push nested-name-specifier locations into dependent template specialization types, but it was the source of the valgrind errors on the buildbots. llvm-svn: 126765
2011-03-02 02:12:44 +08:00
Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), 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) {
Removed redundant location info from ElaboratedTypeLoc / DependentNameLoc / DependentTSTLoc. Uniformed names referencing elaborated keyword. No intended functionality changes. llvm-svn: 149889
2012-02-07 03:09:27 +08:00
Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
Push nested-name-specifier source location information into DependentNameTypeLoc. Teach the recursive AST visitor and libclang how to walk DependentNameTypeLoc nodes. Also, teach libclang about TypedefDecl source ranges, so that we get those. The massive churn in test/Index/recursive-cxx-member-calls.cpp is a good thing: we're annotating a lot more of this test correctly now. llvm-svn: 126729
2011-03-01 09:34:45 +08:00
Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), 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) {
Added location for template keyword in TemplateSpecializationTypeLoc. In the process removed some naming ambiguities. llvm-svn: 149870
2012-02-06 22:41:24 +08:00
Writer.AddSourceLocation(TL.getElaboratedKeywordLoc(), Record);
Push nested-name-specifier source-location information into dependent template specialization types. There are still a few rough edges to clean up with some of the parser actions dropping nested-name-specifiers too early. llvm-svn: 126776
2011-03-02 04:11:18 +08:00
Writer.AddNestedNameSpecifierLoc(TL.getQualifierLoc(), Record);
Added source location for the template keyword in DependentTemplateSpecializationTypeLoc nodes (DTSTLoc). The new info is propagated to TSTLoc on template instantiation, getting rid of 3 FIXMEs in TreeTransform.h and another one Parser.cpp. Simplified code in TypeSpecLocFiller visitor methods for DTSTLoc and DependentNameTypeLoc by removing what now seems to be dead code (adding corresponding assertions). llvm-svn: 149923
2012-02-07 06:45:07 +08:00
Writer.AddSourceLocation(TL.getTemplateKeywordLoc(), Record);
Added location for template keyword in TemplateSpecializationTypeLoc. In the process removed some naming ambiguities. llvm-svn: 149870
2012-02-06 22:41:24 +08:00
Writer.AddSourceLocation(TL.getTemplateNameLoc(), 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
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
}
Introduce a new type, PackExpansionType, to capture types that are pack expansions, e.g. given template<typename... Types> struct tuple; template<typename... Types> struct tuple_of_refs { typedef tuple<Types&...> types; }; the type of the "types" typedef is a PackExpansionType whose pattern is Types&. This commit introduces support for creating pack expansions for template type arguments, as above, but not for any other kind of pack expansion, nor for any form of instantiation. llvm-svn: 122223
2010-12-20 10:24:11 +08:00
void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
Writer.AddSourceLocation(TL.getEllipsisLoc(), 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::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
}
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
Writer.AddSourceLocation(TL.getKWLoc(), Record);
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), 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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTWriter::RecordDataImpl &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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTWriter::RecordDataImpl &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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTWriter::RecordDataImpl &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);
Add an AttributedStmt type to represent a statement with C++11 attributes attached. Since we do not support any attributes which appertain to a statement (yet), testing of this is necessarily quite minimal. Patch by Alexander Kornienko! llvm-svn: 154723
2012-04-14 08:33:13 +08:00
RECORD(STMT_ATTRIBUTED);
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
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);
[ms-inline asm] As part of a larger refactoring, rename AsmStmt to GCCAsmStmt. No functional change intended. llvm-svn: 162632
2012-08-25 08:11:56 +08:00
RECORD(STMT_GCCASM);
[ms-inline asm] Update the AST Reader/Writer for MS-style inline asms. llvm-svn: 162629
2012-08-25 07:51:02 +08:00
RECORD(STMT_MSASM);
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
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_CHOOSE);
RECORD(EXPR_GNU_NULL);
RECORD(EXPR_SHUFFLE_VECTOR);
RECORD(EXPR_BLOCK);
C1X: implement generic selections As an extension, generic selection support has been added for all supported languages. The syntax is the same as for C1X. llvm-svn: 129554
2011-04-15 08:35:48 +08:00
RECORD(EXPR_GENERIC_SELECTION);
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
RECORD(EXPR_OBJC_STRING_LITERAL);
Implements boxed expressions for Objective-C. <rdar://problem/10194391> llvm-svn: 155082
2012-04-19 08:25:12 +08:00
RECORD(EXPR_OBJC_BOXED_EXPRESSION);
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
RECORD(EXPR_OBJC_ARRAY_LITERAL);
RECORD(EXPR_OBJC_DICTIONARY_LITERAL);
add stmt/expr names to BlockInfo block. llvm-svn: 70172
2009-04-27 08:49:53 +08:00
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);
Add clang support for new Objective-C literal syntax for NSDictionary, NSArray, NSNumber, and boolean literals. This includes both Sema and Codegen support. Included is also support for new Objective-C container subscripting. My apologies for the large patch. It was very difficult to break apart. The patch introduces changes to the driver as well to cause clang to link in additional runtime support when needed to support the new language features. Docs are forthcoming to document the implementation and behavior of these features. llvm-svn: 152137
2012-03-07 04:05:56 +08:00
RECORD(EXPR_OBJC_BOOL_LITERAL);
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);
AST representation for user-defined literals, plus just enough of semantic analysis to make the AST representation testable. They are represented by a new UserDefinedLiteral AST node, which is a sugared CallExpr. All semantic properties, including full CodeGen support, are achieved for free by this representation. UserDefinedLiterals can never be dependent, so no custom instantiation behavior is required. They are mangled as if they were direct calls to the underlying literal operator. This matches g++'s apparent behavior (but not its actual mangling, which is broken for literal-operator-ids). User-defined *string* literals are now fully-operational, but the semantic analysis is quite hacky and needs more work. No other forms of user-defined literal are created yet, but the AST support for them is present. This patch committed after midnight because we had already hit the quota for new kinds of literal yesterday. llvm-svn: 152211
2012-03-07 16:35:16 +08:00
RECORD(EXPR_USER_DEFINED_LITERAL);
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
RECORD(EXPR_CXX_BOOL_LITERAL);
RECORD(EXPR_CXX_NULL_PTR_LITERAL);
Update the writing of the block-information block in the AST file format, so that llvm-bcanalyzer knows about all of the various record kinds. llvm-svn: 125086
2011-02-09 00:34:17 +08:00
RECORD(EXPR_CXX_TYPEID_EXPR);
RECORD(EXPR_CXX_TYPEID_TYPE);
RECORD(EXPR_CXX_UUIDOF_EXPR);
RECORD(EXPR_CXX_UUIDOF_TYPE);
RECORD(EXPR_CXX_THIS);
RECORD(EXPR_CXX_THROW);
RECORD(EXPR_CXX_DEFAULT_ARG);
RECORD(EXPR_CXX_BIND_TEMPORARY);
RECORD(EXPR_CXX_SCALAR_VALUE_INIT);
RECORD(EXPR_CXX_NEW);
RECORD(EXPR_CXX_DELETE);
RECORD(EXPR_CXX_PSEUDO_DESTRUCTOR);
RECORD(EXPR_EXPR_WITH_CLEANUPS);
RECORD(EXPR_CXX_DEPENDENT_SCOPE_MEMBER);
RECORD(EXPR_CXX_DEPENDENT_SCOPE_DECL_REF);
RECORD(EXPR_CXX_UNRESOLVED_CONSTRUCT);
RECORD(EXPR_CXX_UNRESOLVED_MEMBER);
RECORD(EXPR_CXX_UNRESOLVED_LOOKUP);
RECORD(EXPR_CXX_UNARY_TYPE_TRAIT);
RECORD(EXPR_CXX_NOEXCEPT);
RECORD(EXPR_OPAQUE_VALUE);
RECORD(EXPR_BINARY_TYPE_TRAIT);
RECORD(EXPR_PACK_EXPANSION);
RECORD(EXPR_SIZEOF_PACK);
RECORD(EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK);
AST, Sema, Serialization: add CUDAKernelCallExpr and related semantic actions llvm-svn: 125217
2011-02-10 05:07:24 +08:00
RECORD(EXPR_CUDA_KERNEL_CALL);
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
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
// Control Block.
BLOCK(CONTROL_BLOCK);
RECORD(METADATA);
RECORD(IMPORTS);
RECORD(LANGUAGE_OPTIONS);
RECORD(TARGET_OPTIONS);
Collapse the original file name and original file ID records into a single record. llvm-svn: 166206
2012-10-19 02:36:53 +08:00
RECORD(ORIGINAL_FILE);
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
RECORD(ORIGINAL_PCH_DIR);
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
RECORD(INPUT_FILE_OFFSETS);
Serialize DiagnosticOptions to the AST file. llvm-svn: 166572
2012-10-24 23:17:15 +08:00
RECORD(DIAGNOSTIC_OPTIONS);
(De-)serialize the file system options. llvm-svn: 166577
2012-10-24 23:49:58 +08:00
RECORD(FILE_SYSTEM_OPTIONS);
(De-)serialize header search options. llvm-svn: 166586
2012-10-25 00:50:34 +08:00
RECORD(HEADER_SEARCH_OPTIONS);
(De-)serialize the preprocessor options, including macros defined, -include'd files, etc. llvm-svn: 166614
2012-10-25 04:05:57 +08:00
RECORD(PREPROCESSOR_OPTIONS);
Describe the new input-files block and its record, for llvm-bcanalyzer. llvm-svn: 166252
2012-10-19 08:45:00 +08:00
BLOCK(INPUT_FILES_BLOCK);
RECORD(INPUT_FILE);
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
// AST Top-Level Block.
BLOCK(AST_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_OFFSET);
RECORD(DECL_OFFSET);
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);
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);
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
RECORD(PPD_ENTITIES_OFFSETS);
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);
Update the writing of the block-information block in the AST file format, so that llvm-bcanalyzer knows about all of the various record kinds. llvm-svn: 125086
2011-02-09 00:34:17 +08:00
RECORD(TU_UPDATE_LEXICAL);
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
RECORD(LOCAL_REDECLARATIONS_MAP);
Update the writing of the block-information block in the AST file format, so that llvm-bcanalyzer knows about all of the various record kinds. llvm-svn: 125086
2011-02-09 00:34:17 +08:00
RECORD(SEMA_DECL_REFS);
RECORD(WEAK_UNDECLARED_IDENTIFIERS);
RECORD(PENDING_IMPLICIT_INSTANTIATIONS);
RECORD(DECL_REPLACEMENTS);
RECORD(UPDATE_VISIBLE);
RECORD(DECL_UPDATE_OFFSETS);
RECORD(DECL_UPDATES);
RECORD(CXX_BASE_SPECIFIER_OFFSETS);
RECORD(DIAG_PRAGMA_MAPPINGS);
Serialization/deserialization support for floating point #pragma options, enabled OpenCL extensions and default FP_CONTRACT setting. llvm-svn: 125589
2011-02-16 03:46:30 +08:00
RECORD(CUDA_SPECIAL_DECL_REFS);
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
RECORD(HEADER_SEARCH_TABLE);
Serialization/deserialization support for floating point #pragma options, enabled OpenCL extensions and default FP_CONTRACT setting. llvm-svn: 125589
2011-02-16 03:46:30 +08:00
RECORD(FP_PRAGMA_OPTIONS);
RECORD(OPENCL_EXTENSIONS);
there i fixed it Increase robustness of the delegating constructor cycle detection mechanism. No more infinite loops on invalid or logic errors leading to false results. Ensure that this is maintained correctly accross serialization. llvm-svn: 130887
2011-05-05 07:29:54 +08:00
RECORD(DELEGATING_CTORS);
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
RECORD(KNOWN_NAMESPACES);
Add some missing record names to the AST output. No functionality change, but llvm-bcanalyzer will be a little more informative now for AST files llvm-svn: 136883
2011-08-05 00:39:39 +08:00
RECORD(MODULE_OFFSET_MAP);
RECORD(SOURCE_MANAGER_LINE_TABLE);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
RECORD(OBJC_CATEGORIES_MAP);
Eliminate the first->last redeclaration map from the AST file format. It's no longer being used, now that we have a new implementation of redeclaration chains. llvm-svn: 146905
2011-12-20 05:09:25 +08:00
RECORD(FILE_SORTED_DECLS);
RECORD(IMPORTED_MODULES);
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
RECORD(MERGED_DECLARATIONS);
RECORD(LOCAL_REDECLARATIONS);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
RECORD(OBJC_CATEGORIES);
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
RECORD(MACRO_OFFSET);
RECORD(MACRO_UPDATES);
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +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);
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
RECORD(SM_SLOC_EXPANSION_ENTRY);
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);
Update the writing of the block-information block in the AST file format, so that llvm-bcanalyzer knows about all of the various record kinds. llvm-svn: 125086
2011-02-09 00:34:17 +08:00
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);
Update the writing of the block-information block in the AST file format, so that llvm-bcanalyzer knows about all of the various record kinds. llvm-svn: 125086
2011-02-09 00:34:17 +08:00
RECORD(TYPE_DECLTYPE);
RECORD(TYPE_ELABORATED);
RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM);
RECORD(TYPE_UNRESOLVED_USING);
RECORD(TYPE_INJECTED_CLASS_NAME);
RECORD(TYPE_OBJC_OBJECT);
RECORD(TYPE_TEMPLATE_TYPE_PARM);
RECORD(TYPE_TEMPLATE_SPECIALIZATION);
RECORD(TYPE_DEPENDENT_NAME);
RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
RECORD(TYPE_PAREN);
RECORD(TYPE_PACK_EXPANSION);
RECORD(TYPE_ATTRIBUTED);
RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
Support for C1x _Atomic specifier (see testcase). This is primarily being committed at the moment to help support C++0x <atomic>, but it should be a solid base for implementing the full specification of C1x _Atomic. Thanks to Jeffrey Yasskin for the thorough review! llvm-svn: 141330
2011-10-07 07:00:33 +08:00
RECORD(TYPE_ATOMIC);
add the decl names. llvm-svn: 70167
2009-04-27 06:32:16 +08:00
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_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);
Update the writing of the block-information block in the AST file format, so that llvm-bcanalyzer knows about all of the various record kinds. llvm-svn: 125086
2011-02-09 00:34:17 +08:00
RECORD(DECL_NAMESPACE);
RECORD(DECL_NAMESPACE_ALIAS);
RECORD(DECL_USING);
RECORD(DECL_USING_SHADOW);
RECORD(DECL_USING_DIRECTIVE);
RECORD(DECL_UNRESOLVED_USING_VALUE);
RECORD(DECL_UNRESOLVED_USING_TYPENAME);
RECORD(DECL_LINKAGE_SPEC);
RECORD(DECL_CXX_RECORD);
RECORD(DECL_CXX_METHOD);
RECORD(DECL_CXX_CONSTRUCTOR);
RECORD(DECL_CXX_DESTRUCTOR);
RECORD(DECL_CXX_CONVERSION);
RECORD(DECL_ACCESS_SPEC);
RECORD(DECL_FRIEND);
RECORD(DECL_FRIEND_TEMPLATE);
RECORD(DECL_CLASS_TEMPLATE);
RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
RECORD(DECL_FUNCTION_TEMPLATE);
RECORD(DECL_TEMPLATE_TYPE_PARM);
RECORD(DECL_NON_TYPE_TEMPLATE_PARM);
RECORD(DECL_TEMPLATE_TEMPLATE_PARM);
RECORD(DECL_STATIC_ASSERT);
RECORD(DECL_CXX_BASE_SPECIFIERS);
RECORD(DECL_INDIRECTFIELD);
RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK);
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
// Statements and Exprs can occur in the Decls and Types block.
AddStmtsExprs(Stream, Record);
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
BLOCK(PREPROCESSOR_DETAIL_BLOCK);
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
RECORD(PPD_MACRO_EXPANSION);
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
RECORD(PPD_MACRO_DEFINITION);
RECORD(PPD_INCLUSION_DIRECTIVE);
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 *
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
adjustFilenameForRelocatablePCH(const char *Filename, StringRef isysroot) {
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
assert(Filename && "No file name to adjust?");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
if (isysroot.empty())
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;
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;
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
for (; Filename[Pos] && Pos < isysroot.size(); ++Pos)
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 (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
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +08:00
/// \brief Write the control block.
(De-)serialize header search options. llvm-svn: 166586
2012-10-25 00:50:34 +08:00
void ASTWriter::WriteControlBlock(Preprocessor &PP, ASTContext &Context,
StringRef isysroot,
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +08:00
const std::string &OutputFile) {
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;
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
Stream.EnterSubblock(CONTROL_BLOCK_ID, 5);
RecordData Record;
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +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
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
BitCodeAbbrev *MetadataAbbrev = new BitCodeAbbrev();
MetadataAbbrev->Add(BitCodeAbbrevOp(METADATA));
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Major
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Minor
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang maj.
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang min.
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Errors
MetadataAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
unsigned MetadataAbbrevCode = Stream.EmitAbbrev(MetadataAbbrev);
Record.push_back(METADATA);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
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);
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
Record.push_back(!isysroot.empty());
[PCH] Mark a PCH file with a flag to indicate if the serialized AST had compiler errors or not. -Control whether ASTReader should reject such a PCH by a boolean flag at ASTReader's creation time. By default, such a PCH file will be rejected with an error when trying to load it. [libclang] Allow clang_saveTranslationUnit to create a PCH file even if compiler errors occurred. -Have libclang API calls accept a PCH that had compiler errors. The general idea is that we want libclang to stay functional even if a PCH had a compiler error. rdar://10976363. llvm-svn: 152192
2012-03-07 09:51:17 +08:00
Record.push_back(ASTHasCompilerErrors);
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
Stream.EmitRecordWithBlob(MetadataAbbrevCode, Record,
getClangFullRepositoryVersion());
In the AST file format, eliminate the CHAINED_METADATA record. Instead, all AST files have a normal METADATA record that has the same form regardless of whether we refer to a chained PCH or any other kind of AST file. Introduce the IMPORTS record, which describes all of the AST files that are imported by this AST file, and how (as a module, a PCH file, etc.). Currently, we emit at most one entry to this record, to support chained PCH. llvm-svn: 137869
2011-08-18 05:07:30 +08:00
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +08:00
// Imports
In the AST file format, eliminate the CHAINED_METADATA record. Instead, all AST files have a normal METADATA record that has the same form regardless of whether we refer to a chained PCH or any other kind of AST file. Introduce the IMPORTS record, which describes all of the AST files that are imported by this AST file, and how (as a module, a PCH file, etc.). Currently, we emit at most one entry to this record, to support chained PCH. llvm-svn: 137869
2011-08-18 05:07:30 +08:00
if (Chain) {
serialization::ModuleManager &Mgr = Chain->getModuleManager();
llvm::SmallVector<char, 128> ModulePaths;
Record.clear();
Keep track of which modules have been loaded directly (e.g., via -import-module) vs. loaded because some other module depends on them. As part of doing this, pass down the module that caused a module to be loaded directly, rather than assuming that we're loading a chain. Finally, write out all of the directly-loaded modules when serializing an AST file (using the new IMPORTS record), so that an AST file can depend on more than one other AST file, all of which will be loaded when that AST file is loaded. This allows us to form and load a tree of modules, but we can't yet load a DAG of modules. llvm-svn: 137923
2011-08-18 12:12:04 +08:00
for (ModuleManager::ModuleIterator M = Mgr.begin(), MEnd = Mgr.end();
M != MEnd; ++M) {
// Skip modules that weren't directly imported.
if (!(*M)->isDirectlyImported())
continue;
Record.push_back((unsigned)(*M)->Kind); // FIXME: Stable encoding
[modules] Setup the import location of a module file and use it as the include location of the main file of an imported module. llvm-svn: 168061
2012-11-16 02:57:22 +08:00
AddSourceLocation((*M)->ImportLoc, Record);
Keep track of which modules have been loaded directly (e.g., via -import-module) vs. loaded because some other module depends on them. As part of doing this, pass down the module that caused a module to be loaded directly, rather than assuming that we're loading a chain. Finally, write out all of the directly-loaded modules when serializing an AST file (using the new IMPORTS record), so that an AST file can depend on more than one other AST file, all of which will be loaded when that AST file is loaded. This allows us to form and load a tree of modules, but we can't yet load a DAG of modules. llvm-svn: 137923
2011-08-18 12:12:04 +08:00
// FIXME: This writes the absolute path for AST files we depend on.
const std::string &FileName = (*M)->FileName;
Record.push_back(FileName.size());
Record.append(FileName.begin(), FileName.end());
}
In the AST file format, eliminate the CHAINED_METADATA record. Instead, all AST files have a normal METADATA record that has the same form regardless of whether we refer to a chained PCH or any other kind of AST file. Introduce the IMPORTS record, which describes all of the AST files that are imported by this AST file, and how (as a module, a PCH file, etc.). Currently, we emit at most one entry to this record, to support chained PCH. llvm-svn: 137869
2011-08-18 05:07:30 +08:00
Stream.EmitRecord(IMPORTS, Record);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +08:00
// Language options.
Record.clear();
const LangOptions &LangOpts = Context.getLangOpts();
#define LANGOPT(Name, Bits, Default, Description) \
Record.push_back(LangOpts.Name);
#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
Record.push_back(static_cast<unsigned>(LangOpts.get##Name()));
#include "clang/Basic/LangOptions.def"
Record.push_back((unsigned) LangOpts.ObjCRuntime.getKind());
AddVersionTuple(LangOpts.ObjCRuntime.getVersion(), Record);
Record.push_back(LangOpts.CurrentModule.size());
Record.append(LangOpts.CurrentModule.begin(), LangOpts.CurrentModule.end());
Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
Split the target options out into their own record within the AST file's control block. llvm-svn: 166195
2012-10-19 01:58:09 +08:00
// Target options.
Record.clear();
Collapse the "version control revision/tag" AST file record into the metadata record, which already had other version information. Clean up the block info block along the way. llvm-svn: 166204
2012-10-19 02:27:37 +08:00
const TargetInfo &Target = Context.getTargetInfo();
const TargetOptions &TargetOpts = Target.getTargetOpts();
Split the target options out into their own record within the AST file's control block. llvm-svn: 166195
2012-10-19 01:58:09 +08:00
AddString(TargetOpts.Triple, Record);
AddString(TargetOpts.CPU, Record);
AddString(TargetOpts.ABI, Record);
AddString(TargetOpts.CXXABI, Record);
AddString(TargetOpts.LinkerVersion, Record);
Record.push_back(TargetOpts.FeaturesAsWritten.size());
for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) {
AddString(TargetOpts.FeaturesAsWritten[I], Record);
}
Record.push_back(TargetOpts.Features.size());
for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) {
AddString(TargetOpts.Features[I], Record);
}
Stream.EmitRecord(TARGET_OPTIONS, Record);
Serialize DiagnosticOptions to the AST file. llvm-svn: 166572
2012-10-24 23:17:15 +08:00
// Diagnostic options.
Record.clear();
const DiagnosticOptions &DiagOpts
= Context.getDiagnostics().getDiagnosticOptions();
#define DIAGOPT(Name, Bits, Default) Record.push_back(DiagOpts.Name);
#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
Record.push_back(static_cast<unsigned>(DiagOpts.get##Name()));
#include "clang/Basic/DiagnosticOptions.def"
Record.push_back(DiagOpts.Warnings.size());
for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I)
AddString(DiagOpts.Warnings[I], Record);
// Note: we don't serialize the log or serialization file names, because they
// are generally transient files and will almost always be overridden.
Stream.EmitRecord(DIAGNOSTIC_OPTIONS, Record);
(De-)serialize the file system options. llvm-svn: 166577
2012-10-24 23:49:58 +08:00
// File system options.
Record.clear();
const FileSystemOptions &FSOpts
= Context.getSourceManager().getFileManager().getFileSystemOptions();
AddString(FSOpts.WorkingDir, Record);
Stream.EmitRecord(FILE_SYSTEM_OPTIONS, Record);
(De-)serialize header search options. llvm-svn: 166586
2012-10-25 00:50:34 +08:00
// Header search options.
Record.clear();
const HeaderSearchOptions &HSOpts
= PP.getHeaderSearchInfo().getHeaderSearchOpts();
AddString(HSOpts.Sysroot, Record);
// Include entries.
Record.push_back(HSOpts.UserEntries.size());
for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
const HeaderSearchOptions::Entry &Entry = HSOpts.UserEntries[I];
AddString(Entry.Path, Record);
Record.push_back(static_cast<unsigned>(Entry.Group));
Record.push_back(Entry.IsUserSupplied);
Record.push_back(Entry.IsFramework);
Record.push_back(Entry.IgnoreSysRoot);
Record.push_back(Entry.IsInternal);
Record.push_back(Entry.ImplicitExternC);
}
// System header prefixes.
Record.push_back(HSOpts.SystemHeaderPrefixes.size());
for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
AddString(HSOpts.SystemHeaderPrefixes[I].Prefix, Record);
Record.push_back(HSOpts.SystemHeaderPrefixes[I].IsSystemHeader);
}
AddString(HSOpts.ResourceDir, Record);
AddString(HSOpts.ModuleCachePath, Record);
Record.push_back(HSOpts.DisableModuleHash);
Record.push_back(HSOpts.UseBuiltinIncludes);
Record.push_back(HSOpts.UseStandardSystemIncludes);
Record.push_back(HSOpts.UseStandardCXXIncludes);
Record.push_back(HSOpts.UseLibcxx);
Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record);
(De-)serialize the preprocessor options, including macros defined, -include'd files, etc. llvm-svn: 166614
2012-10-25 04:05:57 +08:00
// Preprocessor options.
Record.clear();
const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts();
// Macro definitions.
Record.push_back(PPOpts.Macros.size());
for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
AddString(PPOpts.Macros[I].first, Record);
Record.push_back(PPOpts.Macros[I].second);
}
// Includes
Record.push_back(PPOpts.Includes.size());
for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I)
AddString(PPOpts.Includes[I], Record);
// Macro includes
Record.push_back(PPOpts.MacroIncludes.size());
for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I)
AddString(PPOpts.MacroIncludes[I], Record);
Teach the PCH validator to check the preprocessor options, especially the macros that are #define'd or #undef'd on the command line. This checking happens much earlier than the current macro-definition checking and is far cleaner, because it does a direct comparison rather than a diff of the predefines buffers. Moreover, it allows us to use the result of this check to skip over PCH files within a directory that have non-matching -D's or -U's on the command line. Finally, it improves the diagnostics a bit for mismatches, fixing <rdar://problem/8612222>. The old predefines-buffer diff'ing will go away in a subsequent commit. llvm-svn: 166641
2012-10-25 07:41:50 +08:00
Record.push_back(PPOpts.UsePredefines);
(De-)serialize the preprocessor options, including macros defined, -include'd files, etc. llvm-svn: 166614
2012-10-25 04:05:57 +08:00
AddString(PPOpts.ImplicitPCHInclude, Record);
AddString(PPOpts.ImplicitPTHInclude, Record);
Record.push_back(static_cast<unsigned>(PPOpts.ObjCXXARCStandardLibrary));
Stream.EmitRecord(PREPROCESSOR_OPTIONS, Record);
Keep track of the file ID corresponding to the original file used to build a precompiled header. Use this information to eliminate the call to SourceManager::getLocation() while loading a precompiled preamble, since SourceManager::getLocation() itself causes unwanted deserialization. Fixed <rdar://problem/9399352>. llvm-svn: 131021
2011-05-07 05:43:30 +08:00
// Original file name and file ID
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
SourceManager &SM = Context.getSourceManager();
if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
BitCodeAbbrev *FileAbbrev = new BitCodeAbbrev();
Collapse the original file name and original file ID records into a single record. llvm-svn: 166206
2012-10-19 02:36:53 +08:00
FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE));
FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // File ID
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);
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<128> MainFilePath(MainFile->getName());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Replace all uses of PathV1::makeAbsolute with PathV2::fs::make_absolute. llvm-svn: 122340
2010-12-22 00:45:57 +08:00
llvm::sys::fs::make_absolute(MainFilePath);
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);
(De-)serialize the preprocessor options, including macros defined, -include'd files, etc. llvm-svn: 166614
2012-10-25 04:05:57 +08:00
Record.clear();
Collapse the original file name and original file ID records into a single record. llvm-svn: 166206
2012-10-19 02:36:53 +08:00
Record.push_back(ORIGINAL_FILE);
Record.push_back(SM.getMainFileID().getOpaqueValue());
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
Allow resolving headers from a PCH even after headers+PCH were moved to another path. Store in PCH the directory that the PCH was originally created in. If a header file is not found at the path that we expect it to be and the PCH file was moved from its original location, try to resolve the file by assuming that header+PCH were moved together and the header is in the same place relative to the PCH. llvm-svn: 125576
2011-02-16 01:54:22 +08:00
// Original PCH directory
if (!OutputFile.empty() && OutputFile != "-") {
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(ORIGINAL_PCH_DIR));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<128> OutputPath(OutputFile);
Allow resolving headers from a PCH even after headers+PCH were moved to another path. Store in PCH the directory that the PCH was originally created in. If a header file is not found at the path that we expect it to be and the PCH file was moved from its original location, try to resolve the file by assuming that header+PCH were moved together and the header is in the same place relative to the PCH. llvm-svn: 125576
2011-02-16 01:54:22 +08:00
llvm::sys::fs::make_absolute(OutputPath);
StringRef origDir = llvm::sys::path::parent_path(OutputPath);
RecordData Record;
Record.push_back(ORIGINAL_PCH_DIR);
Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
}
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
WriteInputFiles(Context.SourceMgr, isysroot);
Stream.ExitBlock();
}
void ASTWriter::WriteInputFiles(SourceManager &SourceMgr, StringRef isysroot) {
using namespace llvm;
Stream.EnterSubblock(INPUT_FILES_BLOCK_ID, 4);
RecordData Record;
// Create input-file abbreviation.
BitCodeAbbrev *IFAbbrev = new BitCodeAbbrev();
IFAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE));
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Overridden
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
IFAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
unsigned IFAbbrevCode = Stream.EmitAbbrev(IFAbbrev);
// Write out all of the input files.
std::vector<uint32_t> InputFileOffsets;
for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
// Get this source location entry.
const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
ASTWriter.cpp: Fix a warning. [-Wunused-variable] llvm-svn: 166257
2012-10-19 09:53:57 +08:00
assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc);
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
// We only care about file entries that were not overridden.
if (!SLoc->isFile())
continue;
const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
if (!Cache->OrigEntry)
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
continue;
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
// Record this entry's offset.
InputFileOffsets.push_back(Stream.GetCurrentBitNo());
InputFileIDs[Cache->OrigEntry] = InputFileOffsets.size();
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
Record.clear();
Record.push_back(INPUT_FILE);
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
Record.push_back(InputFileOffsets.size());
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
// Emit size/modification time for this file.
Record.push_back(Cache->OrigEntry->getSize());
Record.push_back(Cache->OrigEntry->getModificationTime());
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
// Whether this file was overridden.
Record.push_back(Cache->BufferOverridden);
Move the set of files to be validated in an AST file into the control block, so the input files are validated early on, before we've committed to loading the AST file. This (accidentally) fixed a but wherein the main file used to generate the AST file would *not* be validated by the existing validation logic. At the moment, this leads to some duplication of filenames between the source manager block and input-file blocks, as well as validation logic. This will be handled via an upcoming patch. llvm-svn: 166251
2012-10-19 08:38:02 +08:00
// Turn the file name into an absolute path, if it isn't already.
const char *Filename = Cache->OrigEntry->getName();
SmallString<128> FilePath(Filename);
// Ask the file manager to fixup the relative path for us. This will
// honor the working directory.
SourceMgr.getFileManager().FixupRelativePath(FilePath);
// FIXME: This call to make_absolute shouldn't be necessary, the
// call to FixupRelativePath should always return an absolute path.
llvm::sys::fs::make_absolute(FilePath);
Filename = FilePath.c_str();
Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
Stream.EmitRecordWithBlob(IFAbbrevCode, Record, Filename);
}
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +08:00
Stream.ExitBlock();
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
// Create input file offsets abbreviation.
BitCodeAbbrev *OffsetsAbbrev = new BitCodeAbbrev();
OffsetsAbbrev->Add(BitCodeAbbrevOp(INPUT_FILE_OFFSETS));
OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # input files
OffsetsAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Array
unsigned OffsetsAbbrevCode = Stream.EmitAbbrev(OffsetsAbbrev);
// Write input file offsets.
Record.clear();
Record.push_back(INPUT_FILE_OFFSETS);
Record.push_back(InputFileOffsets.size());
Stream.EmitRecordWithBlob(OffsetsAbbrevCode, Record, data(InputFileOffsets));
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
PCH files only cache successful stats. Remove the code that reads/writes the result code of the stat to/from the PCH file since it is always 0. llvm-svn: 120031
2010-11-24 03:28:12 +08:00
typedef struct stat data_type;
typedef const data_type &data_type_ref;
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
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>
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
EmitKeyDataLength(raw_ostream& Out, const char *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
data_type_ref Data) {
unsigned StrLen = strlen(path);
clang::io::Emit16(Out, StrLen);
PCH files only cache successful stats. Remove the code that reads/writes the result code of the stat to/from the PCH file since it is always 0. llvm-svn: 120031
2010-11-24 03:28:12 +08:00
unsigned DataLen = 4 + 4 + 2 + 8 + 8;
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
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
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) {
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
Out.write(path, KeyLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitData(raw_ostream &Out, key_type_ref,
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
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
PCH files only cache successful stats. Remove the code that reads/writes the result code of the stat to/from the PCH file since it is always 0. llvm-svn: 120031
2010-11-24 03:28:12 +08:00
Emit32(Out, (uint32_t) Data.st_ino);
Emit32(Out, (uint32_t) Data.st_dev);
Emit16(Out, (uint16_t) Data.st_mode);
Emit64(Out, (uint64_t) Data.st_mtime);
Emit64(Out, (uint64_t) Data.st_size);
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
assert(Out.tell() - Start == DataLen && "Wrong data length");
}
};
} // end anonymous namespace
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.
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Input File ID
Boost the efficiency of SourceManager::getMacroArgExpandedLocation. Currently getMacroArgExpandedLocation is very inefficient and for the case of a location pointing at the main file it will end up checking almost all of the SLocEntries. Make it faster: -Use a map of macro argument chunks to their expanded source location. The map is for a single source file, it's stored in the file's ContentCache and lazily computed, like the source lines cache. -In SLocEntry's FileInfo add an 'unsigned NumCreatedFIDs' field that keeps track of the number of FileIDs (files and macros) that were created during preprocessing of that particular file SLocEntry. This is useful when computing the macro argument map in skipping included files while scanning for macro arg FileIDs that lexed from a specific source file. Due to padding, the new field does not increase the size of SLocEntry. llvm-svn: 138225
2011-08-22 07:33:04 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumCreatedFIDs
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 24)); // FirstDeclIndex
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // NumDecls
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
}
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
/// \brief Create an abbreviation for the SLocEntry that refers to a macro
/// expansion.
static unsigned CreateSLocExpansionAbbrev(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();
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_EXPANSION_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
}
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
namespace {
// Trait used for the on-disk hash table of header search information.
class HeaderFileInfoTrait {
ASTWriter &Writer;
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
// Keep track of the framework names we've used during serialization.
SmallVector<char, 128> FrameworkStringData;
llvm::StringMap<unsigned> FrameworkNameOffset;
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
public:
Remove unused private member variables found by clang's new -Wunused-private-field. llvm-svn: 158086
2012-06-07 01:32:50 +08:00
HeaderFileInfoTrait(ASTWriter &Writer)
: Writer(Writer) { }
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
typedef const char *key_type;
typedef key_type key_type_ref;
typedef HeaderFileInfo data_type;
typedef const data_type &data_type_ref;
static unsigned ComputeHash(const char *path) {
// The hash is based only on the filename portion of the key, so that the
// reader can match based on filenames when symlinking or excess path
// elements ("foo/../", "../") change the form of the name. However,
// complete path is still the key.
return llvm::HashString(llvm::sys::path::filename(path));
}
std::pair<unsigned,unsigned>
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
EmitKeyDataLength(raw_ostream& Out, const char *path,
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
data_type_ref Data) {
unsigned StrLen = strlen(path);
clang::io::Emit16(Out, StrLen);
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
unsigned DataLen = 1 + 2 + 4 + 4;
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
clang::io::Emit8(Out, DataLen);
return std::make_pair(StrLen + 1, DataLen);
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitKey(raw_ostream& Out, const char *path, unsigned KeyLen) {
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
Out.write(path, KeyLen);
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitData(raw_ostream &Out, key_type_ref,
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
data_type_ref Data, unsigned DataLen) {
using namespace clang::io;
uint64_t Start = Out.tell(); (void)Start;
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
unsigned char Flags = (Data.isImport << 5)
| (Data.isPragmaOnce << 4)
| (Data.DirInfo << 2)
| (Data.Resolved << 1)
| Data.IndexHeaderMapHeader;
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
Emit8(Out, (uint8_t)Flags);
Emit16(Out, (uint16_t) Data.NumIncludes);
if (!Data.ControllingMacro)
Emit32(Out, (uint32_t)Data.ControllingMacroID);
else
Emit32(Out, (uint32_t)Writer.getIdentifierRef(Data.ControllingMacro));
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
unsigned Offset = 0;
if (!Data.Framework.empty()) {
// If this header refers into a framework, save the framework name.
llvm::StringMap<unsigned>::iterator Pos
= FrameworkNameOffset.find(Data.Framework);
if (Pos == FrameworkNameOffset.end()) {
Offset = FrameworkStringData.size() + 1;
FrameworkStringData.append(Data.Framework.begin(),
Data.Framework.end());
FrameworkStringData.push_back(0);
FrameworkNameOffset[Data.Framework] = Offset;
} else
Offset = Pos->second;
}
Emit32(Out, Offset);
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
assert(Out.tell() - Start == DataLen && "Wrong data length");
}
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
const char *strings_begin() const { return FrameworkStringData.begin(); }
const char *strings_end() const { return FrameworkStringData.end(); }
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
};
} // end anonymous namespace
/// \brief Write the header search block for the list of files that
///
/// \param HS The header search structure to save.
[PCH] When chaining a PCH and serializing HeaderSearch, make sure the HeaderFileInfos from the primary PCH is deserialized, otherwise we lose info that headers were already #imported/#included. llvm-svn: 144510
2011-11-14 06:08:39 +08:00
void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<const FileEntry *, 16> FilesByUID;
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
HS.getFileMgr().GetUniqueIDMapping(FilesByUID);
if (FilesByUID.size() > HS.header_file_size())
FilesByUID.resize(HS.header_file_size());
Remove unused private member variables found by clang's new -Wunused-private-field. llvm-svn: 158086
2012-06-07 01:32:50 +08:00
HeaderFileInfoTrait GeneratorTrait(*this);
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<const char *, 4> SavedStrings;
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
unsigned NumHeaderSearchEntries = 0;
for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
const FileEntry *File = FilesByUID[UID];
if (!File)
continue;
[PCH] When chaining a PCH and serializing HeaderSearch, make sure the HeaderFileInfos from the primary PCH is deserialized, otherwise we lose info that headers were already #imported/#included. llvm-svn: 144510
2011-11-14 06:08:39 +08:00
// Use HeaderSearch's getFileInfo to make sure we get the HeaderFileInfo
// from the external source if it was not provided already.
const HeaderFileInfo &HFI = HS.getFileInfo(File);
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
if (HFI.External && Chain)
continue;
// Turn the file name into an absolute path, if it isn't already.
const char *Filename = File->getName();
Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
// If we performed any translation on the file name at all, we need to
// save this string, since the generator will refer to it later.
if (Filename != File->getName()) {
Filename = strdup(Filename);
SavedStrings.push_back(Filename);
}
Generator.insert(Filename, HFI, GeneratorTrait);
++NumHeaderSearchEntries;
}
// Create the on-disk hash table in a buffer.
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<4096> TableData;
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(TableData);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, GeneratorTrait);
}
// Create a blob abbreviation
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned TableAbbrev = Stream.EmitAbbrev(Abbrev);
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
// Write the header search table
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
RecordData Record;
Record.push_back(HEADER_SEARCH_TABLE);
Record.push_back(BucketOffset);
Record.push_back(NumHeaderSearchEntries);
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
Record.push_back(TableData.size());
TableData.append(GeneratorTrait.strings_begin(),GeneratorTrait.strings_end());
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
Stream.EmitRecordWithBlob(TableAbbrev, Record, TableData.str());
// Free all of the strings we had to duplicate.
for (unsigned I = 0, N = SavedStrings.size(); I != N; ++I)
free((void*)SavedStrings[I]);
}
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,
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
StringRef 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);
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
unsigned SLocExpansionAbbrv = CreateSLocExpansionAbbrev(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
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;
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
SLocEntryOffsets.reserve(SourceMgr.local_sloc_entry_size() - 1);
for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
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
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.
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
[PCH/Module] Change the map of file-level DeclIDs to use a FileID as key instead of a SLocEntry pointer. This allows the array of file sorted declarations in a PCH/module to be deterministic. llvm-svn: 165047
2012-10-03 05:09:17 +08:00
FileID FID = FileID::get(I);
assert(&SourceMgr.getSLocEntry(FID) == SLoc);
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()) {
Implement (de-)serialization of the buffer contents for an overridden file in the source manager. This allows us to properly create and use modules described by module map files without umbrella headers (or with incompletely umbrella headers). More generally, we can actually build a PCH file that makes use of file -> buffer remappings, which could be useful in libclang in the future. llvm-svn: 144830
2011-11-17 04:05:18 +08:00
const SrcMgr::ContentCache *Cache = SLoc->getFile().getContentCache();
if (Cache->OrigEntry) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = SM_SLOC_FILE_ENTRY;
[PCH] Store the offsets of source location file entries and go through them in ASTReader::validateFileEntries(). This avoids going through all source location entries and fixes the performance regression. Many thanks to Doug for the hint! (rdar://9530587) llvm-svn: 132481
2011-06-03 04:01:46 +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
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
Code = SM_SLOC_EXPANSION_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);
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
// Starting offset of this entry within this module, so skip the dummy.
Record.push_back(SLoc->getOffset() - 2);
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
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();
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
if (Content->OrigEntry) {
assert(Content->OrigEntry == Content->ContentsEntry &&
Implement (de-)serialization of the buffer contents for an overridden file in the source manager. This allows us to properly create and use modules described by module map files without umbrella headers (or with incompletely umbrella headers). More generally, we can actually build a PCH file that makes use of file -> buffer remappings, which could be useful in libclang in the future. llvm-svn: 144830
2011-11-17 04:05:18 +08:00
"Writing to AST an overridden file is not supported");
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
// The source location entry is a file. Emit input file ID.
assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry");
Record.push_back(InputFileIDs[Content->OrigEntry]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Boost the efficiency of SourceManager::getMacroArgExpandedLocation. Currently getMacroArgExpandedLocation is very inefficient and for the case of a location pointing at the main file it will end up checking almost all of the SLocEntries. Make it faster: -Use a map of macro argument chunks to their expanded source location. The map is for a single source file, it's stored in the file's ContentCache and lazily computed, like the source lines cache. -In SLocEntry's FileInfo add an 'unsigned NumCreatedFIDs' field that keeps track of the number of FileIDs (files and macros) that were created during preprocessing of that particular file SLocEntry. This is useful when computing the macro argument map in skipping included files while scanning for macro arg FileIDs that lexed from a specific source file. Due to padding, the new field does not increase the size of SLocEntry. llvm-svn: 138225
2011-08-22 07:33:04 +08:00
Record.push_back(File.NumCreatedFIDs);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
[PCH/Module] Change the map of file-level DeclIDs to use a FileID as key instead of a SLocEntry pointer. This allows the array of file sorted declarations in a PCH/module to be deterministic. llvm-svn: 165047
2012-10-03 05:09:17 +08:00
FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
if (FDI != FileDeclIDs.end()) {
Record.push_back(FDI->second->FirstDeclIndex);
Record.push_back(FDI->second->DeclIDs.size());
} else {
Record.push_back(0);
Record.push_back(0);
}
Implement (de-)serialization of the buffer contents for an overridden file in the source manager. This allows us to properly create and use modules described by module map files without umbrella headers (or with incompletely umbrella headers). More generally, we can actually build a PCH file that makes use of file -> buffer remappings, which could be useful in libclang in the future. llvm-svn: 144830
2011-11-17 04:05:18 +08:00
Eliminate the redundancy between source-file information in the source manager block and input-file information in the control block. The source manager entries now point back into the control block. Input files are now lazily deserialized (if validation is disabled). Reduces Cocoa's PCH by the ~70k I added when I introduced the redundancy in r166251. llvm-svn: 166429
2012-10-23 02:42:04 +08:00
Stream.EmitRecordWithAbbrev(SLocFileAbbrv, Record);
Implement (de-)serialization of the buffer contents for an overridden file in the source manager. This allows us to properly create and use modules described by module map files without umbrella headers (or with incompletely umbrella headers). More generally, we can actually build a PCH file that makes use of file -> buffer remappings, which could be useful in libclang in the future. llvm-svn: 144830
2011-11-17 04:05:18 +08:00
if (Content->BufferOverridden) {
Record.clear();
Record.push_back(SM_SLOC_BUFFER_BLOB);
const llvm::MemoryBuffer *Buffer
= Content->getBuffer(PP.getDiagnostics(), PP.getSourceManager());
Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
StringRef(Buffer->getBufferStart(),
Buffer->getBufferSize() + 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
} 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,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
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,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef(Buffer->getBufferStart(),
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
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
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
if (strcmp(Name, "<built-in>") == 0) {
PreloadSLocs.push_back(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 {
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
// The source location entry is a macro expansion.
Migrate 'Instantiation' data and API bits of SLocEntry to 'Expansion' etc. With this I think essentially all of the SourceManager APIs are converted. Comments and random other bits of cleanup should be all thats left. llvm-svn: 136057
2011-07-26 12:56:51 +08:00
const SrcMgr::ExpansionInfo &Expansion = SLoc->getExpansion();
Convert InstantiationInfo and much of the related code to ExpansionInfo and various other 'expansion' based terms. I've tried to reformat where appropriate and catch as many references in comments but I'm going to do several more passes. Also I've tried to expand parameter names to be more clear where appropriate. llvm-svn: 136056
2011-07-26 12:41:47 +08:00
Record.push_back(Expansion.getSpellingLoc().getRawEncoding());
Record.push_back(Expansion.getExpansionLocStart().getRawEncoding());
[PCH] When writing out ExpansionInfo, make sure we don't lose track if it's a macro arg expansion or not. llvm-svn: 137792
2011-08-17 08:31:14 +08:00
Record.push_back(Expansion.isMacroArgExpansion() ? 0
: Expansion.getExpansionLocEnd().getRawEncoding());
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
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.
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
unsigned NextOffset = SourceMgr.getNextLocalOffset();
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)
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
NextOffset = SourceMgr.getLocalSLocEntry(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);
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
Stream.EmitRecordWithAbbrev(SLocExpansionAbbrv, 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
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // total size
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::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());
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
Record.push_back(SourceMgr.getNextLocalOffset() - 1); // skip dummy
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, data(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
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);
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
// Write the line table. It depends on remapping working, so it must come
// after the source location offsets.
if (SourceMgr.hasLineTable()) {
LineTableInfo &LineTable = SourceMgr.getLineTable();
Record.clear();
// 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);
Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
unsigned FilenameLen = Filename? strlen(Filename) : 0;
Record.push_back(FilenameLen);
if (FilenameLen)
Record.insert(Record.end(), Filename, Filename + FilenameLen);
}
// Emit the line entries
for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end();
L != LEnd; ++L) {
// Only emit entries for local files.
Switch LineTableInfo to use FileID instead of int for file references, from Tom Honermann! llvm-svn: 158211
2012-06-09 00:40:28 +08:00
if (L->first.ID < 0)
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
continue;
// Emit the file ID
Switch LineTableInfo to use FileID instead of int for file references, from Tom Honermann! llvm-svn: 158211
2012-06-09 00:40:28 +08:00
Record.push_back(L->first.ID);
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
// Emit the line entries
Record.push_back(L->second.size());
for (std::vector<LineEntry>::iterator LE = L->second.begin(),
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);
}
}
Stream.EmitRecord(SOURCE_MANAGER_LINE_TABLE, 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
}
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
//===----------------------------------------------------------------------===//
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
static int compareMacroDefinitions(const void *XPtr, const void *YPtr) {
const std::pair<const IdentifierInfo *, MacroInfo *> &X =
*(const std::pair<const IdentifierInfo *, MacroInfo *>*)XPtr;
const std::pair<const IdentifierInfo *, MacroInfo *> &Y =
*(const std::pair<const IdentifierInfo *, MacroInfo *>*)YPtr;
return X.first->getName().compare(Y.first->getName());
}
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.
///
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
if (PPRec)
WritePreprocessorDetail(*PPRec);
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.
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +08:00
Stream.EnterSubblock(PREPROCESSOR_BLOCK_ID, 3);
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
Extend the preprocessing record and libclang with support for inclusion directives, keeping track of every #include, #import, etc. in the translation unit. We keep track of the source location and kind of the inclusion, how the file name was spelled, and the underlying file to which the inclusion resolved. llvm-svn: 116952
2010-10-21 06:00:55 +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.
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
// Construct the list of macro definitions that need to be serialized.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<std::pair<const IdentifierInfo *, MacroInfo *>, 2>
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
MacrosToEmit;
llvm::SmallPtrSet<const IdentifierInfo*, 4> MacroDefinitionsSeen;
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0),
Implement AST/PCH chaining support for macro definitions. Previously, we would deserialize all of the macro definitions we knew about while serializing the macro definitions at the end of the AST/PCH file. Even though we skipped most of them (since they were unchanged), it's still a performance problem. Now, we do the standard AST/PCH chaining trick: watch what identifiers are deserialized as macro names, and consider only those identifiers (along with macro definitions that have been deserialized/written in the source) when serializing the preprocessor state. llvm-svn: 125324
2011-02-11 08:26:14 +08:00
E = PP.macro_end(Chain == 0);
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
I != E; ++I) {
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
if (!IsModule || I->second->isPublic()) {
MacroDefinitionsSeen.insert(I->first);
MacrosToEmit.push_back(std::make_pair(I->first, I->second));
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
}
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
}
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
// Sort the set of macro definitions that need to be serialized by the
// name of the macro, to provide a stable ordering.
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
llvm::array_pod_sort(MacrosToEmit.begin(), MacrosToEmit.end(),
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
&compareMacroDefinitions);
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
/// \brief Offsets of each of the macros into the bitstream, indexed by
/// the local macro ID
///
/// For each identifier that is associated with a macro, this map
/// provides the offset into the bitstream where that macro is
/// defined.
std::vector<uint32_t> MacroOffsets;
When we're writing macro definitions to an AST/PCH File, sort the macro definitions by macro name first. That way, we'll get a stable ordering in the AST/PCH file. llvm-svn: 125297
2011-02-11 02:20:09 +08:00
for (unsigned I = 0, N = MacrosToEmit.size(); I != N; ++I) {
const IdentifierInfo *Name = MacrosToEmit[I].first;
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
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
for (MacroInfo *MI = MacrosToEmit[I].second; MI;
MI = MI->getPreviousDefinition()) {
MacroID ID = getMacroRef(MI);
if (!ID)
continue;
// Skip macros from a AST file if we're chaining.
if (Chain && MI->isFromAST() && !MI->hasChangedAfterLoad())
continue;
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
if (ID < FirstMacroID) {
// This will have been dealt with via an update record.
assert(MacroUpdates.count(MI) > 0 && "Missing macro update");
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
continue;
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
}
// Record the local offset of this macro.
unsigned Index = ID - FirstMacroID;
if (Index == MacroOffsets.size())
MacroOffsets.push_back(Stream.GetCurrentBitNo());
else {
if (Index > MacroOffsets.size())
MacroOffsets.resize(Index + 1);
MacroOffsets[Index] = Stream.GetCurrentBitNo();
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
AddIdentifierRef(Name, Record);
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
addMacroRef(MI, Record);
Deserialize macro history when we deserialize an identifier that has macro history. When deserializing macro history, we arrange history such that the macros that have definitions (that haven't been #undef'd) and are visible come at the beginning of the list, which is what the preprocessor and other clients of Preprocessor::getMacroInfo() expect. If additional macro definitions become visible later, they'll be moved toward the front of the list. Note that it's possible to have ambiguities, but we don't diagnose them yet. There is a partially-implemented design decision here that, if a particular identifier has been defined or #undef'd within the translation unit, that definition (or #undef) hides any macro definitions that come from imported modules. There's still a little work to do to ensure that the right #undef'ing happens. Additionally, we'll need to scope the update records for #undefs, so they only kick in when the submodule containing that update record becomes visible. llvm-svn: 165682
2012-10-11 08:46:49 +08:00
Record.push_back(inferSubmoduleIDFromLocation(MI->getDefinitionLoc()));
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
AddSourceLocation(MI->getDefinitionLoc(), Record);
AddSourceLocation(MI->getUndefLoc(), Record);
Record.push_back(MI->isUsed());
Record.push_back(MI->isPublic());
AddSourceLocation(MI->getVisibilityLocation(), Record);
unsigned Code;
if (MI->isObjectLike()) {
Code = PP_MACRO_OBJECT_LIKE;
} else {
Code = PP_MACRO_FUNCTION_LIKE;
Record.push_back(MI->isC99Varargs());
Record.push_back(MI->isGNUVarargs());
Suppress elided variadic macro argument extension diagnostic for macros using the related comma pasting extension. In certain cases, we used to get two diagnostics for what is essentially one extension. This change suppresses the first diagnostic in certain cases where we know we're going to print the second diagnostic. The diagnostic is redundant, and it can't be suppressed in the definition of the macro because it points at the use of the macro, so we want to avoid printing it if possible. The implementation works by detecting constructs which look like comma pasting at the time of the definition of the macro; this information is then used when the macro is used. (We can't actually detect whether we're using the comma pasting extension until the macro is actually used, but we can detecting constructs which will be comma pasting if the varargs argument is elided.) <rdar://problem/12292192> llvm-svn: 167907
2012-11-14 10:18:46 +08:00
Record.push_back(MI->hasCommaPasting());
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
Record.push_back(MI->getNumArgs());
for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
I != E; ++I)
AddIdentifierRef(*I, Record);
}
improve punctuation llvm-svn: 68791
2009-04-11 01:16:57 +08:00
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
// If we have a detailed preprocessing record, record the macro definition
// ID that corresponds to this macro.
if (PPRec)
Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
Stream.EmitRecord(Code, Record);
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
Record.clear();
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +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);
Record.push_back(Tok.getLocation().getRawEncoding());
Record.push_back(Tok.getLength());
// FIXME: When reading literal tokens, reconstruct the literal pointer
// if it is needed.
AddIdentifierRef(Tok.getIdentifierInfo(), Record);
// 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());
Stream.EmitRecord(PP_TOKEN, Record);
Record.clear();
}
++NumMacros;
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +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
}
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
Stream.ExitBlock();
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
// Write the offsets table for macro IDs.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(MACRO_OFFSET));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of macros
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned MacroOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Record.clear();
Record.push_back(MACRO_OFFSET);
Record.push_back(MacroOffsets.size());
Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS);
Stream.EmitRecordWithBlob(MacroOffsetAbbrev, Record,
data(MacroOffsets));
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
}
void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
Introduce local_begin()/local_end() methods in PreprocessingRecord which return iterators for local, non-loaded, preprocessed entities. llvm-svn: 140062
2011-09-20 04:40:42 +08:00
if (PPRec.local_begin() == PPRec.local_end())
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
return;
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Introduce PreprocessingRecord::getPreprocessedEntitiesInRange() which will do a binary search and return a pair of iterators for preprocessed entities in the given source range. Source ranges of preprocessed entities are stored twice currently in the PCH/Module file but this will be fixed in a subsequent commit. llvm-svn: 140058
2011-09-20 04:40:25 +08:00
SmallVector<PPEntityOffset, 64> PreprocessedEntityOffsets;
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
// Enter the preprocessor block.
Stream.EnterSubblock(PREPROCESSOR_DETAIL_BLOCK_ID, 3);
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +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;
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
using namespace llvm;
// Set up the abbreviation for
unsigned InclusionAbbrev = 0;
{
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(PPD_INCLUSION_DIRECTIVE));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
Add info in the preprocessing record whether an inclusion directive resulted in an automatic module import. llvm-svn: 165022
2012-10-03 00:10:46 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // imported module
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
InclusionAbbrev = Stream.EmitAbbrev(Abbrev);
}
Introduce local -> global mapping for preprocessed entity IDs. This is the last of the ID/offset/index mappings that I know of. Unfortunately, the "gap" method of testing doesn't work here due to the way the preprocessing record performs iteration. We'll do more testing once multi-AST loading is possible. llvm-svn: 136902
2011-08-05 02:56:47 +08:00
unsigned FirstPreprocessorEntityID
= (Chain ? PPRec.getNumLoadedPreprocessedEntities() : 0)
+ NUM_PREDEF_PP_ENTITY_IDS;
unsigned NextPreprocessorEntityID = FirstPreprocessorEntityID;
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
RecordData Record;
Introduce local_begin()/local_end() methods in PreprocessingRecord which return iterators for local, non-loaded, preprocessed entities. llvm-svn: 140062
2011-09-20 04:40:42 +08:00
for (PreprocessingRecord::iterator E = PPRec.local_begin(),
EEnd = PPRec.local_end();
In the AST reader and writer, slide the preprocessed entity IDs by +1 so that we use ID zero as a sentinel for "no result". This matches the convention set by all of the other global IDs. llvm-svn: 136885
2011-08-05 01:06:18 +08:00
E != EEnd;
(void)++E, ++NumPreprocessingRecords, ++NextPreprocessorEntityID) {
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
Record.clear();
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Introduce PreprocessingRecord::getPreprocessedEntitiesInRange() which will do a binary search and return a pair of iterators for preprocessed entities in the given source range. Source ranges of preprocessed entities are stored twice currently in the PCH/Module file but this will be fixed in a subsequent commit. llvm-svn: 140058
2011-09-20 04:40:25 +08:00
PreprocessedEntityOffsets.push_back(PPEntityOffset((*E)->getSourceRange(),
Stream.GetCurrentBitNo()));
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) {
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
// Record this macro definition's ID.
MacroDefinitions[MD] = NextPreprocessorEntityID;
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
AddIdentifierRef(MD->getName(), Record);
Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
continue;
}
Move the rest of the preprocessor terminology from 'instantiate' and variants to 'expand'. This changed a couple of public APIs, including one public type "MacroInstantiation" which is now "MacroExpansion". The rest of the codebase was updated to reflect this, especially the libclang code. Two of the C++ (and thus easily changed) libclang APIs were updated as well because they pertained directly to the old MacroInstantiation class. No functionality changed. llvm-svn: 135139
2011-07-14 16:20:46 +08:00
if (MacroExpansion *ME = dyn_cast<MacroExpansion>(*E)) {
[libclang] Fix annotation and getting a "macro expansion" cursor for a builtin macro expansion. llvm-svn: 139298
2011-09-09 01:18:41 +08:00
Record.push_back(ME->isBuiltinMacro());
if (ME->isBuiltinMacro())
AddIdentifierRef(ME->getName(), Record);
else
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Record.push_back(MacroDefinitions[ME->getDefinition()]);
Move the Serialization library from 'instantiation' to 'expansion', with the exception of its uses of SourceManager and SourceLocation APIs. llvm-svn: 135260
2011-07-15 15:25:21 +08:00
Stream.EmitRecord(PPD_MACRO_EXPANSION, Record);
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
continue;
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
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
if (InclusionDirective *ID = dyn_cast<InclusionDirective>(*E)) {
Record.push_back(PPD_INCLUSION_DIRECTIVE);
Record.push_back(ID->getFileName().size());
Record.push_back(ID->wasInQuotes());
Record.push_back(static_cast<unsigned>(ID->getKind()));
Add info in the preprocessing record whether an inclusion directive resulted in an automatic module import. llvm-svn: 165022
2012-10-03 00:10:46 +08:00
Record.push_back(ID->importedModule());
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<64> Buffer;
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
Buffer += ID->getFileName();
[libclang] Fix a crash when serializing a preprocessing record that contains an #include entry that did not resolve to header file. Part of rdar://11007039 llvm-svn: 152275
2012-03-08 09:08:28 +08:00
// Check that the FileEntry is not null because it was not resolved and
// we create a PCH even with compiler errors.
if (ID->getFile())
Buffer += ID->getFile()->getName();
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
Stream.EmitRecordWithBlob(InclusionAbbrev, Record, Buffer);
continue;
}
llvm_unreachable("Unhandled PreprocessedEntity in ASTWriter");
}
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();
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +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
// Write the offsets table for the preprocessing record.
if (NumPreprocessingRecords > 0) {
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
assert(PreprocessedEntityOffsets.size() == 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
// Write the offsets table for identifier IDs.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(PPD_ENTITIES_OFFSETS));
Introduce local -> global mapping for preprocessed entity IDs. This is the last of the ID/offset/index mappings that I know of. Unfortunately, the "gap" method of testing doesn't work here due to the way the preprocessing record performs iteration. We'll do more testing once multi-AST loading is possible. llvm-svn: 136902
2011-08-05 02:56:47 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first pp entity
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::Blob));
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
unsigned PPEOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +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
Record.clear();
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Record.push_back(PPD_ENTITIES_OFFSETS);
Introduce local -> global mapping for preprocessed entity IDs. This is the last of the ID/offset/index mappings that I know of. Unfortunately, the "gap" method of testing doesn't work here due to the way the preprocessing record performs iteration. We'll do more testing once multi-AST loading is possible. llvm-svn: 136902
2011-08-05 02:56:47 +08:00
Record.push_back(FirstPreprocessorEntityID - NUM_PREDEF_PP_ENTITY_IDS);
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
Stream.EmitRecordWithBlob(PPEOffsetAbbrev, Record,
data(PreprocessedEntityOffsets));
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
}
Arrange for the preprocessor to be passed down into the PCH writer. llvm-svn: 68790
2009-04-11 01:15:23 +08:00
}
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
unsigned ASTWriter::getSubmoduleID(Module *Mod) {
llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod);
if (Known != SubmoduleIDs.end())
return Known->second;
return SubmoduleIDs[Mod] = NextSubmoduleID++;
}
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
/// \brief Compute the number of modules within the given tree (including the
/// given module).
static unsigned getNumberOfModules(Module *Mod) {
unsigned ChildModules = 0;
Store the submodules of a module in source order, as they are stored in the module map. This provides a bit more predictability for the user, as well as eliminating the need to sort the submodules when serializing them. llvm-svn: 147564
2012-01-05 07:32:19 +08:00
for (Module::submodule_iterator Sub = Mod->submodule_begin(),
SubEnd = Mod->submodule_end();
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
Sub != SubEnd; ++Sub)
Store the submodules of a module in source order, as they are stored in the module map. This provides a bit more predictability for the user, as well as eliminating the need to sort the submodules when serializing them. llvm-svn: 147564
2012-01-05 07:32:19 +08:00
ChildModules += getNumberOfModules(*Sub);
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
return ChildModules + 1;
}
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
void ASTWriter::WriteSubmodules(Module *WritingModule) {
Actually add a useful bit to the comment pre-FIXME llvm-svn: 145809
2011-12-06 00:35:23 +08:00
// Determine the dependencies of our module and each of it's submodules.
When writing a module file, keep track of the set of (sub)modules that it imports, establishing dependencies at the (sub)module granularity. This is not a user-visible change (yet). llvm-svn: 145808
2011-12-06 00:33:54 +08:00
// FIXME: This feels like it belongs somewhere else, but there are no
// other consumers of this information.
SourceManager &SrcMgr = PP->getSourceManager();
ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
for (ASTContext::import_iterator I = Context->local_import_begin(),
IEnd = Context->local_import_end();
I != IEnd; ++I) {
if (Module *ImportedFrom
= ModMap.inferModuleFromLocation(FullSourceLoc(I->getLocation(),
SrcMgr))) {
ImportedFrom->Imports.push_back(I->getImportedModule());
}
}
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
// Enter the submodule description block.
Stream.EnterSubblock(SUBMODULE_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
// Write the abbreviations needed for the submodules block.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
Introduce module attributes into the module map grammar, along with a single attribute ("system") that allows us to mark a module as being a "system" module. Each of the headers that makes up a system module is considered to be a system header, so that we (for example) suppress warnings there. If a module is being inferred for a framework, and that framework directory is within a system frameworks directory, infer it as a system framework. llvm-svn: 149143
2012-01-28 03:52:33 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
Parse inferred submodules in module maps, track their contents in Module, and (de-)serialize this information. Semantics of inferred submodules to follow. llvm-svn: 145864
2011-12-06 06:27:44 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
unsigned DefinitionAbbrev = Stream.EmitAbbrev(Abbrev);
Abbrev = new BitCodeAbbrev();
Implement umbrella directories for modules, which are similar to umbrella headers in the sense that all of the headers within that directory (and eventually its subdirectories) are considered to be part of the module with that umbrella directory. However, unlike umbrella headers, which are expected to include all of the headers within their subdirectories, Clang will automatically include all of the headers it finds in the named subdirectory. The intent here is to allow a module map to trivially turn a subdirectory into a module, where the module's structure can mimic the directory structure. llvm-svn: 146165
2011-12-09 03:11:24 +08:00
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_HEADER));
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
unsigned UmbrellaAbbrev = Stream.EmitAbbrev(Abbrev);
Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_HEADER));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
unsigned HeaderAbbrev = Stream.EmitAbbrev(Abbrev);
Implement umbrella directories for modules, which are similar to umbrella headers in the sense that all of the headers within that directory (and eventually its subdirectories) are considered to be part of the module with that umbrella directory. However, unlike umbrella headers, which are expected to include all of the headers within their subdirectories, Clang will automatically include all of the headers it finds in the named subdirectory. The intent here is to allow a module map to trivially turn a subdirectory into a module, where the module's structure can mimic the directory structure. llvm-svn: 146165
2011-12-09 03:11:24 +08:00
[Modules] Introduce Module::TopHeaders which is a set of top-level headers that are associated with a (sub)module. llvm-svn: 165279
2012-10-05 08:22:33 +08:00
Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_TOPHEADER));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
unsigned TopHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
Implement umbrella directories for modules, which are similar to umbrella headers in the sense that all of the headers within that directory (and eventually its subdirectories) are considered to be part of the module with that umbrella directory. However, unlike umbrella headers, which are expected to include all of the headers within their subdirectories, Clang will automatically include all of the headers it finds in the named subdirectory. The intent here is to allow a module map to trivially turn a subdirectory into a module, where the module's structure can mimic the directory structure. llvm-svn: 146165
2011-12-09 03:11:24 +08:00
Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_UMBRELLA_DIR));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
unsigned UmbrellaDirAbbrev = Stream.EmitAbbrev(Abbrev);
Implement support for module requirements, which indicate the language features needed for a particular module to be available. This allows mixed-language modules, where certain headers only work under some language variants (e.g., in C++, std.tuple might only be available in C++11 mode). llvm-svn: 147387
2011-12-31 12:05:44 +08:00
Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_REQUIRES));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Feature
unsigned RequiresAbbrev = Stream.EmitAbbrev(Abbrev);
Introduce the notion of excluded headers into the module map description. Previously, one could emulate this behavior by placing the header in an always-unavailable submodule, but Argyrios guilted me into expressing this idea properly. llvm-svn: 165921
2012-10-15 14:28:11 +08:00
Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_EXCLUDED_HEADER));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Name
unsigned ExcludedHeaderAbbrev = Stream.EmitAbbrev(Abbrev);
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
// Write the submodule metadata block.
RecordData Record;
Record.push_back(getNumberOfModules(WritingModule));
Record.push_back(FirstSubmoduleID - NUM_PREDEF_SUBMODULE_IDS);
Stream.EmitRecord(SUBMODULE_METADATA, Record);
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
// Write all of the submodules.
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
std::queue<Module *> Q;
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Q.push(WritingModule);
while (!Q.empty()) {
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
Module *Mod = Q.front();
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Q.pop();
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
unsigned ID = getSubmoduleID(Mod);
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
// Emit the definition of the block.
Record.clear();
Record.push_back(SUBMODULE_DEFINITION);
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
Record.push_back(ID);
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
if (Mod->Parent) {
assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?");
Record.push_back(SubmoduleIDs[Mod->Parent]);
} else {
Record.push_back(0);
}
Record.push_back(Mod->IsFramework);
Record.push_back(Mod->IsExplicit);
Introduce module attributes into the module map grammar, along with a single attribute ("system") that allows us to mark a module as being a "system" module. Each of the headers that makes up a system module is considered to be a system header, so that we (for example) suppress warnings there. If a module is being inferred for a framework, and that framework directory is within a system frameworks directory, infer it as a system framework. llvm-svn: 149143
2012-01-28 03:52:33 +08:00
Record.push_back(Mod->IsSystem);
Parse inferred submodules in module maps, track their contents in Module, and (de-)serialize this information. Semantics of inferred submodules to follow. llvm-svn: 145864
2011-12-06 06:27:44 +08:00
Record.push_back(Mod->InferSubmodules);
Record.push_back(Mod->InferExplicitSubmodules);
Record.push_back(Mod->InferExportWildcard);
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Stream.EmitRecordWithBlob(DefinitionAbbrev, Record, Mod->Name);
Implement support for module requirements, which indicate the language features needed for a particular module to be available. This allows mixed-language modules, where certain headers only work under some language variants (e.g., in C++, std.tuple might only be available in C++11 mode). llvm-svn: 147387
2011-12-31 12:05:44 +08:00
// Emit the requirements.
for (unsigned I = 0, N = Mod->Requires.size(); I != N; ++I) {
Record.clear();
Record.push_back(SUBMODULE_REQUIRES);
Stream.EmitRecordWithBlob(RequiresAbbrev, Record,
Mod->Requires[I].data(),
Mod->Requires[I].size());
}
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
// Emit the umbrella header, if there is one.
Within the module representation, generalize the notion of an umbrella header to also support umbrella directories. The umbrella directory for an umbrella header is the directory in which the umbrella header resides. No functionality change yet, but it's coming. llvm-svn: 146158
2011-12-09 01:39:04 +08:00
if (const FileEntry *UmbrellaHeader = Mod->getUmbrellaHeader()) {
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Record.clear();
Implement umbrella directories for modules, which are similar to umbrella headers in the sense that all of the headers within that directory (and eventually its subdirectories) are considered to be part of the module with that umbrella directory. However, unlike umbrella headers, which are expected to include all of the headers within their subdirectories, Clang will automatically include all of the headers it finds in the named subdirectory. The intent here is to allow a module map to trivially turn a subdirectory into a module, where the module's structure can mimic the directory structure. llvm-svn: 146165
2011-12-09 03:11:24 +08:00
Record.push_back(SUBMODULE_UMBRELLA_HEADER);
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Stream.EmitRecordWithBlob(UmbrellaAbbrev, Record,
Within the module representation, generalize the notion of an umbrella header to also support umbrella directories. The umbrella directory for an umbrella header is the directory in which the umbrella header resides. No functionality change yet, but it's coming. llvm-svn: 146158
2011-12-09 01:39:04 +08:00
UmbrellaHeader->getName());
Implement umbrella directories for modules, which are similar to umbrella headers in the sense that all of the headers within that directory (and eventually its subdirectories) are considered to be part of the module with that umbrella directory. However, unlike umbrella headers, which are expected to include all of the headers within their subdirectories, Clang will automatically include all of the headers it finds in the named subdirectory. The intent here is to allow a module map to trivially turn a subdirectory into a module, where the module's structure can mimic the directory structure. llvm-svn: 146165
2011-12-09 03:11:24 +08:00
} else if (const DirectoryEntry *UmbrellaDir = Mod->getUmbrellaDir()) {
Record.clear();
Record.push_back(SUBMODULE_UMBRELLA_DIR);
Stream.EmitRecordWithBlob(UmbrellaDirAbbrev, Record,
UmbrellaDir->getName());
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
}
// Emit the headers.
for (unsigned I = 0, N = Mod->Headers.size(); I != N; ++I) {
Record.clear();
Record.push_back(SUBMODULE_HEADER);
Stream.EmitRecordWithBlob(HeaderAbbrev, Record,
Mod->Headers[I]->getName());
}
Introduce the notion of excluded headers into the module map description. Previously, one could emulate this behavior by placing the header in an always-unavailable submodule, but Argyrios guilted me into expressing this idea properly. llvm-svn: 165921
2012-10-15 14:28:11 +08:00
// Emit the excluded headers.
for (unsigned I = 0, N = Mod->ExcludedHeaders.size(); I != N; ++I) {
Record.clear();
Record.push_back(SUBMODULE_EXCLUDED_HEADER);
Stream.EmitRecordWithBlob(ExcludedHeaderAbbrev, Record,
Mod->ExcludedHeaders[I]->getName());
}
[Modules] Introduce Module::TopHeaders which is a set of top-level headers that are associated with a (sub)module. llvm-svn: 165279
2012-10-05 08:22:33 +08:00
for (unsigned I = 0, N = Mod->TopHeaders.size(); I != N; ++I) {
Record.clear();
Record.push_back(SUBMODULE_TOPHEADER);
Stream.EmitRecordWithBlob(TopHeaderAbbrev, Record,
Mod->TopHeaders[I]->getName());
}
When writing a module file, keep track of the set of (sub)modules that it imports, establishing dependencies at the (sub)module granularity. This is not a user-visible change (yet). llvm-svn: 145808
2011-12-06 00:33:54 +08:00
// Emit the imports.
if (!Mod->Imports.empty()) {
Record.clear();
for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) {
Tweak submodule ID handling in the AST writer llvm-svn: 146445
2011-12-13 07:17:57 +08:00
unsigned ImportedID = getSubmoduleID(Mod->Imports[I]);
When writing a module file, keep track of the set of (sub)modules that it imports, establishing dependencies at the (sub)module granularity. This is not a user-visible change (yet). llvm-svn: 145808
2011-12-06 00:33:54 +08:00
assert(ImportedID && "Unknown submodule!");
Record.push_back(ImportedID);
}
Stream.EmitRecord(SUBMODULE_IMPORTS, Record);
}
Implement (de-)serialization of the set of exported modules in a module map. llvm-svn: 145695
2011-12-03 02:58:38 +08:00
// Emit the exports.
if (!Mod->Exports.empty()) {
Record.clear();
for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) {
Tweak submodule ID handling in the AST writer llvm-svn: 146445
2011-12-13 07:17:57 +08:00
if (Module *Exported = Mod->Exports[I].getPointer()) {
unsigned ExportedID = SubmoduleIDs[Exported];
assert(ExportedID > 0 && "Unknown submodule ID?");
Record.push_back(ExportedID);
} else {
Record.push_back(0);
}
Implement (de-)serialization of the set of exported modules in a module map. llvm-svn: 145695
2011-12-03 02:58:38 +08:00
Record.push_back(Mod->Exports[I].getInt());
}
Stream.EmitRecord(SUBMODULE_EXPORTS, Record);
}
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
// Queue up the submodules of this module.
Store the submodules of a module in source order, as they are stored in the module map. This provides a bit more predictability for the user, as well as eliminating the need to sort the submodules when serializing them. llvm-svn: 147564
2012-01-05 07:32:19 +08:00
for (Module::submodule_iterator Sub = Mod->submodule_begin(),
SubEnd = Mod->submodule_end();
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
Sub != SubEnd; ++Sub)
Store the submodules of a module in source order, as they are stored in the module map. This provides a bit more predictability for the user, as well as eliminating the need to sort the submodules when serializing them. llvm-svn: 147564
2012-01-05 07:32:19 +08:00
Q.push(*Sub);
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
}
Stream.ExitBlock();
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
assert((NextSubmoduleID - FirstSubmoduleID
== getNumberOfModules(WritingModule)) && "Wrong # of submodules");
Implement (de-)serialization of the description of a module and its submodules. This information will eventually be used for name hiding when dealing with submodules. For now, we only use it to ensure that the module "key" returned when loading a module will always be a module (rather than occasionally being a FileEntry). llvm-svn: 145497
2011-12-01 01:33:56 +08:00
}
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
serialization::SubmoduleID
ASTWriter::inferSubmoduleIDFromLocation(SourceLocation Loc) {
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
if (Loc.isInvalid() || !WritingModule)
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
return 0; // No submodule
When writing a module file, keep track of the set of (sub)modules that it imports, establishing dependencies at the (sub)module granularity. This is not a user-visible change (yet). llvm-svn: 145808
2011-12-06 00:33:54 +08:00
// Find the module that owns this location.
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
ModuleMap &ModMap = PP->getHeaderSearchInfo().getModuleMap();
When writing a module file, keep track of the set of (sub)modules that it imports, establishing dependencies at the (sub)module granularity. This is not a user-visible change (yet). llvm-svn: 145808
2011-12-06 00:33:54 +08:00
Module *OwningMod
= ModMap.inferModuleFromLocation(FullSourceLoc(Loc,PP->getSourceManager()));
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
if (!OwningMod)
return 0;
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
// Check whether this submodule is part of our own module.
if (WritingModule != OwningMod && !OwningMod->isSubModuleOf(WritingModule))
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
return 0;
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
return getSubmoduleID(OwningMod);
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
}
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
void ASTWriter::WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag) {
[PCH] The diagnostic state points can refer to previously created diagnostic states; make sure the ASTReader sets the diagnostic state properly instead of always recreating it. Fixes rdar://12581618 & http://llvm.org/PR14181 llvm-svn: 166987
2012-10-30 08:27:21 +08:00
// FIXME: Make it work properly with modules.
llvm::SmallDenseMap<const DiagnosticsEngine::DiagState *, unsigned, 64>
DiagStateIDMap;
unsigned CurrID = 0;
DiagStateIDMap[&Diag.DiagStates.front()] = ++CurrID; // the command-line one.
Read/write from/to PCH the diagnostic mappings that the user set so that e.g. #pragma clang diagnostic can be used in a PCH. Fixes rdar://8435969. llvm-svn: 118303
2010-11-06 06:10:18 +08:00
RecordData Record;
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
for (DiagnosticsEngine::DiagStatePointsTy::const_iterator
Properly propagate #pragma diagnostic mappings from PCH but not command-line warning flags. Addresses rdar://8435969&8852495 llvm-svn: 123462
2011-01-15 04:54:07 +08:00
I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end();
I != E; ++I) {
[PCH] The diagnostic state points can refer to previously created diagnostic states; make sure the ASTReader sets the diagnostic state properly instead of always recreating it. Fixes rdar://12581618 & http://llvm.org/PR14181 llvm-svn: 166987
2012-10-30 08:27:21 +08:00
const DiagnosticsEngine::DiagStatePoint &point = *I;
Properly propagate #pragma diagnostic mappings from PCH but not command-line warning flags. Addresses rdar://8435969&8852495 llvm-svn: 123462
2011-01-15 04:54:07 +08:00
if (point.Loc.isInvalid())
continue;
Record.push_back(point.Loc.getRawEncoding());
[PCH] The diagnostic state points can refer to previously created diagnostic states; make sure the ASTReader sets the diagnostic state properly instead of always recreating it. Fixes rdar://12581618 & http://llvm.org/PR14181 llvm-svn: 166987
2012-10-30 08:27:21 +08:00
unsigned &DiagStateID = DiagStateIDMap[point.State];
Record.push_back(DiagStateID);
if (DiagStateID == 0) {
DiagStateID = ++CurrID;
for (DiagnosticsEngine::DiagState::const_iterator
I = point.State->begin(), E = point.State->end(); I != E; ++I) {
if (I->second.isPragma()) {
Record.push_back(I->first);
Record.push_back(I->second.getMapping());
}
Properly propagate #pragma diagnostic mappings from PCH but not command-line warning flags. Addresses rdar://8435969&8852495 llvm-svn: 123462
2011-01-15 04:54:07 +08:00
}
[PCH] The diagnostic state points can refer to previously created diagnostic states; make sure the ASTReader sets the diagnostic state properly instead of always recreating it. Fixes rdar://12581618 & http://llvm.org/PR14181 llvm-svn: 166987
2012-10-30 08:27:21 +08:00
Record.push_back(-1); // mark the end of the diag/map pairs for this
// location.
Read/write from/to PCH the diagnostic mappings that the user set so that e.g. #pragma clang diagnostic can be used in a PCH. Fixes rdar://8435969. llvm-svn: 118303
2010-11-06 06:10:18 +08:00
}
}
Don't write an empty DIAG_USER_MAPPINGS record. llvm-svn: 118305
2010-11-06 06:20:49 +08:00
if (!Record.empty())
Properly propagate #pragma diagnostic mappings from PCH but not command-line warning flags. Addresses rdar://8435969&8852495 llvm-svn: 123462
2011-01-15 04:54:07 +08:00
Stream.EmitRecord(DIAG_PRAGMA_MAPPINGS, Record);
Read/write from/to PCH the diagnostic mappings that the user set so that e.g. #pragma clang diagnostic can be used in a PCH. Fixes rdar://8435969. llvm-svn: 118303
2010-11-06 06:10:18 +08:00
}
Write CXX base specifier offsets for chained ASTs. llvm-svn: 127126
2011-03-07 02:41:18 +08:00
void ASTWriter::WriteCXXBaseSpecifiersOffsets() {
if (CXXBaseSpecifiersOffsets.empty())
return;
RecordData Record;
// Create a blob abbreviation for the C++ base specifiers offsets.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(CXX_BASE_SPECIFIER_OFFSETS));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned BaseSpecifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
// Write the base specifier offsets table.
Write CXX base specifier offsets for chained ASTs. llvm-svn: 127126
2011-03-07 02:41:18 +08:00
Record.clear();
Record.push_back(CXX_BASE_SPECIFIER_OFFSETS);
Record.push_back(CXXBaseSpecifiersOffsets.size());
Stream.EmitRecordWithBlob(BaseSpecifierOffsetAbbrev, Record,
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
data(CXXBaseSpecifiersOffsets));
Write CXX base specifier offsets for chained ASTs. llvm-svn: 127126
2011-03-07 02:41:18 +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);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
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;
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
Stream.EmitRecordWithBlob(DeclContextLexicalAbbrev, Record, data(Decls));
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
Implement a proper local -> global type ID remapping scheme in the AST reader. This scheme permits an AST file to be loaded with its type IDs shifted anywhere in the type ID space. At present, the type indices are still allocated in the same boring way they always have been, just by adding up the number of types in each PCH file within the chain. However, I've done testing with this patch by randomly sliding the base indices at load time, to ensure that remapping is occurring as expected. I may eventually formalize this in some testing flag, but loading multiple (non-chained) AST files at once will eventually exercise the same code. There is one known problem with this patch, which involves name lookup of operator names (e.g., "x.operator int*()") in cases where multiple PCH files in the chain. The hash function itself depends on having a stable type ID, which doesn't happen with chained PCH and *certainly* doesn't happen when sliding type IDs around. We'll need another approach. I'll tackle that next. llvm-svn: 136693
2011-08-03 00:26:37 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base type index
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
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());
Implement a proper local -> global type ID remapping scheme in the AST reader. This scheme permits an AST file to be loaded with its type IDs shifted anywhere in the type ID space. At present, the type indices are still allocated in the same boring way they always have been, just by adding up the number of types in each PCH file within the chain. However, I've done testing with this patch by randomly sliding the base indices at load time, to ensure that remapping is occurring as expected. I may eventually formalize this in some testing flag, but loading multiple (non-chained) AST files at once will eventually exercise the same code. There is one known problem with this patch, which involves name lookup of operator names (e.g., "x.operator int*()") in cases where multiple PCH files in the chain. The hash function itself depends on having a stable type ID, which doesn't happen with chained PCH and *certainly* doesn't happen when sliding type IDs around. We'll need another approach. I'll tackle that next. llvm-svn: 136693
2011-08-03 00:26:37 +08:00
Record.push_back(FirstTypeID - NUM_PREDEF_TYPE_IDS);
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, data(TypeOffsets));
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
// 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
Introduce the local -> global declaration ID mapping into the AST reader, to allow AST files to be loaded with their declarations remapped to different ID numbers. Fix a number of places where we were either failing to map local declaration IDs into global declaration IDs or where interpreting the local declaration IDs within the wrong module. I've tested this via the usual "random gaps" method. It works well except for the preamble tests, because our handling of the precompiled preamble requires declaration and preprocessed entity to be stable when parsing code and then loading that back into memory. This property will hold in general, but my randomized testing naturally breaks this property to get more coverage. In the future, I expect that the precompiled preamble logic won't need this property. I am very unhappy with the current handling of the translation unit, which is a rather egregious hack. We're going to have to do something very different here for loading multiple AST files, because we don't want to have to cope with merging two translation units. Likely, we'll just handle translation units entirely via "update" records, and predefine a single, fixed declaration ID for the translation unit. That will come later. llvm-svn: 136779
2011-08-03 23:48:04 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // base decl ID
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
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());
Introduce a constant for the number of predefined declarations in an AST file, along with an enumeration naming those predefined declarations. No functionality change, but this will make it easier to introduce new predefined declarations, when/if we need them. llvm-svn: 136781
2011-08-04 00:05:40 +08:00
Record.push_back(FirstDeclID - NUM_PREDEF_DECL_IDS);
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, data(DeclOffsets));
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
}
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
void ASTWriter::WriteFileDeclIDsMap() {
using namespace llvm;
RecordData Record;
// Join the vectors of DeclIDs from all files.
SmallVector<DeclID, 256> FileSortedIDs;
for (FileDeclIDsTy::iterator
FI = FileDeclIDs.begin(), FE = FileDeclIDs.end(); FI != FE; ++FI) {
DeclIDInFileInfo &Info = *FI->second;
Info.FirstDeclIndex = FileSortedIDs.size();
for (LocDeclIDsTy::iterator
DI = Info.DeclIDs.begin(), DE = Info.DeclIDs.end(); DI != DE; ++DI)
FileSortedIDs.push_back(DI->second);
}
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(FILE_SORTED_DECLS));
[libclang] When indexing an AST file, only deserialize the file level declarations of the current primary module. llvm-svn: 165046
2012-10-03 05:09:13 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned AbbrevCode = Stream.EmitAbbrev(Abbrev);
Record.push_back(FILE_SORTED_DECLS);
[libclang] When indexing an AST file, only deserialize the file level declarations of the current primary module. llvm-svn: 165046
2012-10-03 05:09:13 +08:00
Record.push_back(FileSortedIDs.size());
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
Stream.EmitRecordWithBlob(AbbrevCode, Record, data(FileSortedIDs));
}
Structured comment parsing, first step. * Retain comments in the AST * Serialize/deserialize comments * Find comments attached to a certain Decl * Expose raw comment text and SourceRange via libclang llvm-svn: 158771
2012-06-20 08:34:58 +08:00
void ASTWriter::WriteComments() {
Stream.EnterSubblock(COMMENTS_BLOCK_ID, 3);
Don't store pointers into a std::vector (RawCommentList::Comments). Although currently we take address of std::vector's contents only after we finished adding all comments (so no reallocation can happen), this will change in future. llvm-svn: 159845
2012-07-07 02:19:34 +08:00
ArrayRef<RawComment *> RawComments = Context->Comments.getComments();
Structured comment parsing, first step. * Retain comments in the AST * Serialize/deserialize comments * Find comments attached to a certain Decl * Expose raw comment text and SourceRange via libclang llvm-svn: 158771
2012-06-20 08:34:58 +08:00
RecordData Record;
Don't store pointers into a std::vector (RawCommentList::Comments). Although currently we take address of std::vector's contents only after we finished adding all comments (so no reallocation can happen), this will change in future. llvm-svn: 159845
2012-07-07 02:19:34 +08:00
for (ArrayRef<RawComment *>::iterator I = RawComments.begin(),
E = RawComments.end();
Structured comment parsing, first step. * Retain comments in the AST * Serialize/deserialize comments * Find comments attached to a certain Decl * Expose raw comment text and SourceRange via libclang llvm-svn: 158771
2012-06-20 08:34:58 +08:00
I != E; ++I) {
Record.clear();
Don't store pointers into a std::vector (RawCommentList::Comments). Although currently we take address of std::vector's contents only after we finished adding all comments (so no reallocation can happen), this will change in future. llvm-svn: 159845
2012-07-07 02:19:34 +08:00
AddSourceRange((*I)->getSourceRange(), Record);
Record.push_back((*I)->getKind());
Record.push_back((*I)->isTrailingComment());
Record.push_back((*I)->isAlmostTrailingComment());
Structured comment parsing, first step. * Retain comments in the AST * Serialize/deserialize comments * Find comments attached to a certain Decl * Expose raw comment text and SourceRange via libclang llvm-svn: 158771
2012-06-20 08:34:58 +08:00
Stream.EmitRecord(COMMENTS_RAW_COMMENT, Record);
}
Stream.ExitBlock();
}
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>
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
EmitKeyDataLength(raw_ostream& Out, Selector 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
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
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitKey(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
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitData(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) {
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!M->Method->isFromASTFile())
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
changed = true;
}
for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method;
M = M->Next) {
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!M->Method->isFromASTFile())
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
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.
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
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));
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // size
Introduce local -> global selector ID mapping into the AST reader. Tested with the usual "gaps" method. llvm-svn: 136839
2011-08-04 07:28:44 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
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::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());
Introduce local -> global selector ID mapping into the AST reader. Tested with the usual "gaps" method. llvm-svn: 136839
2011-08-04 07:28:44 +08:00
Record.push_back(FirstSelectorID - NUM_PREDEF_SELECTOR_IDS);
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
Stream.EmitRecordWithBlob(SelectorOffsetAbbrev, Record,
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
data(SelectorOffsets));
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;
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
IdentifierResolver &IdResolver;
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
bool IsModule;
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.
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
bool isInterestingIdentifier(IdentifierInfo *II, MacroInfo *&Macro) {
if (II->isPoisoned() ||
II->isExtensionToken() ||
II->getObjCOrBuiltinID() ||
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
II->hasRevertedTokenIDToIdentifier() ||
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
II->getFETokenInfo<void>())
return true;
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
return hadMacroDefinition(II, Macro);
Don't try to write a macro offset for an identifier that names a non-exported macro, for real this time llvm-svn: 139745
2011-09-15 06:14:14 +08:00
}
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
bool hadMacroDefinition(IdentifierInfo *II, MacroInfo *&Macro) {
if (!II->hadMacroDefinition())
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
return false;
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
if (Macro || (Macro = PP.getMacroInfoHistory(II)))
For modules, all macros that aren't include guards are implicitly public. Add a __private_macro__ directive to hide a macro, similar to the __module_private__ declaration specifier. llvm-svn: 142188
2011-10-17 23:32:29 +08:00
return !Macro->isBuiltinMacro() && (!IsModule || Macro->isPublic());
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
return false;
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
}
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:
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
typedef IdentifierInfo* key_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 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
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP,
IdentifierResolver &IdResolver, bool IsModule)
: Writer(Writer), PP(PP), IdResolver(IdResolver), IsModule(IsModule) { }
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>
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
EmitKeyDataLength(raw_ostream& Out, IdentifierInfo* II, 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
Don't try to write a macro offset for an identifier that names a non-exported macro, for real this time llvm-svn: 139745
2011-09-15 06:14:14 +08:00
MacroInfo *Macro = 0;
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
if (isInterestingIdentifier(II, Macro)) {
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
DataLen += 2; // 2 bytes for builtin ID
DataLen += 2; // 2 bytes for flags
Deserialize macro history when we deserialize an identifier that has macro history. When deserializing macro history, we arrange history such that the macros that have definitions (that haven't been #undef'd) and are visible come at the beginning of the list, which is what the preprocessor and other clients of Preprocessor::getMacroInfo() expect. If additional macro definitions become visible later, they'll be moved toward the front of the list. Note that it's possible to have ambiguities, but we don't diagnose them yet. There is a partially-implemented design decision here that, if a particular identifier has been defined or #undef'd within the translation unit, that definition (or #undef) hides any macro definitions that come from imported modules. There's still a little work to do to ensure that the right #undef'ing happens. Additionally, we'll need to scope the update records for #undefs, so they only kick in when the submodule containing that update record becomes visible. llvm-svn: 165682
2012-10-11 08:46:49 +08:00
if (hadMacroDefinition(II, Macro)) {
for (MacroInfo *M = Macro; M; M = M->getPreviousDefinition()) {
if (Writer.getMacroRef(M) != 0)
DataLen += 4;
}
DataLen += 4;
}
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
for (IdentifierResolver::iterator D = IdResolver.begin(II),
DEnd = IdResolver.end();
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
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
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitKey(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
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
void EmitData(raw_ostream& Out, IdentifierInfo* II,
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ID, unsigned) {
Don't try to write a macro offset for an identifier that names a non-exported macro, for real this time llvm-svn: 139745
2011-09-15 06:14:14 +08:00
MacroInfo *Macro = 0;
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
if (!isInterestingIdentifier(II, Macro)) {
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);
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);
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
uint32_t Bits = (uint32_t)II->getObjCOrBuiltinID();
assert((Bits & 0xffff) == Bits && "ObjCOrBuiltinID too big for ASTReader.");
clang::io::Emit16(Out, Bits);
Bits = 0;
bool HadMacroDefinition = hadMacroDefinition(II, Macro);
Bits = (Bits << 1) | unsigned(HadMacroDefinition);
Fix a few MSVC warnings. llvm-svn: 91714
2009-12-19 04:58:47 +08:00
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
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +08:00
if (HadMacroDefinition) {
Deserialize macro history when we deserialize an identifier that has macro history. When deserializing macro history, we arrange history such that the macros that have definitions (that haven't been #undef'd) and are visible come at the beginning of the list, which is what the preprocessor and other clients of Preprocessor::getMacroInfo() expect. If additional macro definitions become visible later, they'll be moved toward the front of the list. Note that it's possible to have ambiguities, but we don't diagnose them yet. There is a partially-implemented design decision here that, if a particular identifier has been defined or #undef'd within the translation unit, that definition (or #undef) hides any macro definitions that come from imported modules. There's still a little work to do to ensure that the right #undef'ing happens. Additionally, we'll need to scope the update records for #undefs, so they only kick in when the submodule containing that update record becomes visible. llvm-svn: 165682
2012-10-11 08:46:49 +08:00
// Write all of the macro IDs associated with this identifier.
for (MacroInfo *M = Macro; M; M = M->getPreviousDefinition()) {
if (MacroID ID = Writer.getMacroRef(M))
clang::io::Emit32(Out, ID);
}
clang::io::Emit32(Out, 0);
Implement name hiding for macro definitions within modules, such that only the macro definitions from visible (sub)modules will actually be visible. This provides the same behavior for macros that r145640 provided for declarations. llvm-svn: 145683
2011-12-02 23:45:10 +08:00
}
Macro history (de-)serialization. Deserialization currently reads only the latest macro definition. Needs more work. Summary: Passes all tests (+ the new one with code completion), but needs a thorough review in part related to modules. Reviewers: doug.gregor Reviewed By: alexfh CC: cfe-commits, rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D41 llvm-svn: 164610
2012-09-26 01:18:14 +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
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
// "stat"), but the ASTReader 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.
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
SmallVector<Decl *, 16> Decls(IdResolver.begin(II),
IdResolver.end());
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
for (SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(),
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
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.
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
IdentifierResolver &IdResolver,
bool IsModule) {
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;
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
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");
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
if (!Chain || !ID->first->isFromAST() ||
ID->first->hasChangedSinceDeserialization())
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
Generator.insert(const_cast<IdentifierInfo *>(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.
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
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
{
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
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
Introduce a local-to-global remapping for identifiers in the AST reader, and fix up the one (!) place where we were improperly mapping a local ID to a global ID. Tested via the usual "gaps" trick. llvm-svn: 136817
2011-08-04 05:49:18 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
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::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());
Introduce a local-to-global remapping for identifiers in the AST reader, and fix up the one (!) place where we were improperly mapping a local ID to a global ID. Tested via the usual "gaps" trick. llvm-svn: 136817
2011-08-04 05:49:18 +08:00
Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_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
Stream.EmitRecordWithBlob(IdentifierOffsetAbbrev, Record,
Use template magic to make dumping of vectors slightly less fragile. No intended functionality change. llvm-svn: 130114
2011-04-25 01:44:50 +08:00
data(IdentifierOffsets));
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:
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>
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
EmitKeyDataLength(raw_ostream& Out, DeclarationName Name,
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
data_type_ref Lookup) {
unsigned KeyLen = 1;
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXLiteralOperatorName:
KeyLen += 4;
break;
case DeclarationName::CXXOperatorName:
KeyLen += 1;
break;
Change the hashing function for DeclContext lookup within an AST file by eliminating the type ID from constructor, destructor, and conversion function names. There are several reasons for this change: - A given type (say, int*) isn't guaranteed to have a single, unique type ID within a chain of PCH files. Hence, we could end up hashing based on the wrong type ID, causing name lookup to fail. - The mapping from types back to type IDs required one DenseMap entry for every type that was ever deserialized, which was an unacceptable cost to support just the name lookup of constructors, destructors, and conversion functions. Plus, this mapping could never actually work with chained or multiple PCH, based on the first bullet. Once we have eliminated the type from the hash function, these problems go away, as does my horrible "reverse type remap" hack, which was doomed from the start (see bullet #1 above) and far too complicated. However, note that removing the type from the hash function means that all constructors, destructors, and conversion functions have the same hash key, so I've updated the caller to double-check that the declarations found have the appropriate name. llvm-svn: 136708
2011-08-03 02:32:54 +08:00
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
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
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);
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitKey(raw_ostream& Out, DeclarationName Name, unsigned) {
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
using namespace clang::io;
Emit8(Out, Name.getNameKind());
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
return;
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
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector()));
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
return;
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
case DeclarationName::CXXOperatorName:
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
assert(Name.getCXXOverloadedOperator() < NUM_OVERLOADED_OPERATORS &&
"Invalid operator?");
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
Emit8(Out, Name.getCXXOverloadedOperator());
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
return;
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
case DeclarationName::CXXLiteralOperatorName:
Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
return;
Change the hashing function for DeclContext lookup within an AST file by eliminating the type ID from constructor, destructor, and conversion function names. There are several reasons for this change: - A given type (say, int*) isn't guaranteed to have a single, unique type ID within a chain of PCH files. Hence, we could end up hashing based on the wrong type ID, causing name lookup to fail. - The mapping from types back to type IDs required one DenseMap entry for every type that was ever deserialized, which was an unacceptable cost to support just the name lookup of constructors, destructors, and conversion functions. Plus, this mapping could never actually work with chained or multiple PCH, based on the first bullet. Once we have eliminated the type from the hash function, these problems go away, as does my horrible "reverse type remap" hack, which was doomed from the start (see bullet #1 above) and far too complicated. However, note that removing the type from the hash function means that all constructors, destructors, and conversion functions have the same hash key, so I've updated the caller to double-check that the declarations found have the appropriate name. llvm-svn: 136708
2011-08-03 02:32:54 +08:00
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
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
case DeclarationName::CXXUsingDirective:
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
return;
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
}
ASTWriter: Tighten up assertions when emitting a declaration name. clang has recently started to warn about the enum compares: lib/Serialization/ASTWriter.cpp:2760:31: warning: comparison of literal 256 with expression of type 'clang::DeclarationName::NameKind' is always true [-Wtautological-constant-out-of-range-compare] llvm-svn: 164220
2012-09-19 21:40:40 +08:00
llvm_unreachable("Invalid name kind?");
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
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void EmitData(raw_ostream& Out, key_type_ref,
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
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 ?
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (DC->isTranslationUnit() && !Context.getLangOpts().CPlusPlus)
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
return 0;
// 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();
Fix Objective-C compilation-time performance regression introduced in r152608. Reintroduce lazy name lookup table building, ensuring that the lazy building step produces the same lookup table that would be built by the eager step. Avoid building a lookup table for the translation unit outside C++, even in cases where we can't recover the contents of the table from the declaration chain on the translation unit, since we're not going to perform qualified lookup into it anyway. Continue to support lazily building such lookup tables for now, though, since ASTMerge uses them. In my tests, this performs very similarly to ToT with r152608 backed out, for C, Obj-C and C++, and does not suffer from PR10447. llvm-svn: 152905
2012-03-16 14:12:59 +08:00
StoredDeclsMap *Map = DC->buildLookup();
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
if (!Map || Map->empty())
return 0;
OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
ASTDeclContextNameLookupTrait Trait(*this);
// Create the on-disk hash table representation.
When writing out the entries in a lookup table for a DeclContext, make sure that all of the CXXConversionDecls go into the same bucket. Otherwise, name lookup might not find them all. Fixes <rdar://problem/10041960>. llvm-svn: 138824
2011-08-31 04:49:19 +08:00
DeclarationName ConversionName;
llvm::SmallVector<NamedDecl *, 4> ConversionDecls;
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
for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
D != DEnd; ++D) {
DeclarationName Name = D->first;
DeclContext::lookup_result Result = D->second.getLookupResult();
When writing out the entries in a lookup table for a DeclContext, make sure that all of the CXXConversionDecls go into the same bucket. Otherwise, name lookup might not find them all. Fixes <rdar://problem/10041960>. llvm-svn: 138824
2011-08-31 04:49:19 +08:00
if (Result.first != Result.second) {
if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
// Hash all conversion function names to the same name. The actual
// type information in conversion function name is not used in the
// key (since such type information is not stable across different
// modules), so the intended effect is to coalesce all of the conversion
// functions under a single key.
if (!ConversionName)
ConversionName = Name;
ConversionDecls.append(Result.first, Result.second);
continue;
}
In ASTWriter::WriteDeclContextVisibleBlock, don't write empty lookups. Empty lookups can occur in the DeclContext map when we are chaining PCHs, where the empty lookup indicates that we already looked in ExternalASTSource. llvm-svn: 138816
2011-08-31 03:43:23 +08:00
Generator.insert(Name, Result, Trait);
When writing out the entries in a lookup table for a DeclContext, make sure that all of the CXXConversionDecls go into the same bucket. Otherwise, name lookup might not find them all. Fixes <rdar://problem/10041960>. llvm-svn: 138824
2011-08-31 04:49:19 +08:00
}
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
}
When writing out the entries in a lookup table for a DeclContext, make sure that all of the CXXConversionDecls go into the same bucket. Otherwise, name lookup might not find them all. Fixes <rdar://problem/10041960>. llvm-svn: 138824
2011-08-31 04:49:19 +08:00
// Add the conversion functions
if (!ConversionDecls.empty()) {
Generator.insert(ConversionName,
DeclContext::lookup_result(ConversionDecls.begin(),
ConversionDecls.end()),
Trait);
}
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
// Create the on-disk hash table in a buffer.
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<4096> LookupTable;
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
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
Fix Objective-C compilation-time performance regression introduced in r152608. Reintroduce lazy name lookup table building, ensuring that the lazy building step produces the same lookup table that would be built by the eager step. Avoid building a lookup table for the translation unit outside C++, even in cases where we can't recover the contents of the table from the declaration chain on the translation unit, since we're not going to perform qualified lookup into it anyway. Continue to support lazily building such lookup tables for now, though, since ASTMerge uses them. In my tests, this performs very similarly to ToT with r152608 backed out, for C, Obj-C and C++, and does not suffer from PR10447. llvm-svn: 152905
2012-03-16 14:12:59 +08:00
/// (in C++), for namespaces, and for classes with forward-declared unscoped
/// enumeration members (in C++11).
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
void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
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.
In ASTWriter::WriteDeclContextVisibleBlock, don't write empty lookups. Empty lookups can occur in the DeclContext map when we are chaining PCHs, where the empty lookup indicates that we already looked in ExternalASTSource. llvm-svn: 138816
2011-08-31 03:43:23 +08:00
if (Result.first != Result.second)
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.
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<4096> LookupTable;
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
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());
}
Serialization/deserialization support for floating point #pragma options, enabled OpenCL extensions and default FP_CONTRACT setting. llvm-svn: 125589
2011-02-16 03:46:30 +08:00
/// \brief Write an FP_PRAGMA_OPTIONS block for the given FPOptions.
void ASTWriter::WriteFPPragmaOptions(const FPOptions &Opts) {
RecordData Record;
Record.push_back(Opts.fp_contract);
Stream.EmitRecord(FP_PRAGMA_OPTIONS, Record);
}
/// \brief Write an OPENCL_EXTENSIONS block for the given OpenCLOptions.
void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (!SemaRef.Context.getLangOpts().OpenCL)
Serialization/deserialization support for floating point #pragma options, enabled OpenCL extensions and default FP_CONTRACT setting. llvm-svn: 125589
2011-02-16 03:46:30 +08:00
return;
const OpenCLOptions &Opts = SemaRef.getOpenCLOptions();
RecordData Record;
#define OPENCLEXT(nm) Record.push_back(Opts.nm);
#include "clang/Basic/OpenCLExtensions.def"
Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
}
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
void ASTWriter::WriteRedeclarations() {
RecordData LocalRedeclChains;
SmallVector<serialization::LocalRedeclarationsInfo, 2> LocalRedeclsMap;
for (unsigned I = 0, N = Redeclarations.size(); I != N; ++I) {
Decl *First = Redeclarations[I];
assert(First->getPreviousDecl() == 0 && "Not the first declaration?");
Decl *MostRecent = First->getMostRecentDecl();
// If we only have a single declaration, there is no point in storing
// a redeclaration chain.
if (First == MostRecent)
continue;
unsigned Offset = LocalRedeclChains.size();
unsigned Size = 0;
LocalRedeclChains.push_back(0); // Placeholder for the size.
// Collect the set of local redeclarations of this declaration.
for (Decl *Prev = MostRecent; Prev != First;
Prev = Prev->getPreviousDecl()) {
if (!Prev->isFromASTFile()) {
AddDeclRef(Prev, LocalRedeclChains);
++Size;
}
}
LocalRedeclChains[Offset] = Size;
// Reverse the set of local redeclarations, so that we store them in
// order (since we found them in reverse order).
std::reverse(LocalRedeclChains.end() - Size, LocalRedeclChains.end());
// Add the mapping from the first ID to the set of local declarations.
LocalRedeclarationsInfo Info = { getDeclID(First), Offset };
LocalRedeclsMap.push_back(Info);
assert(N == Redeclarations.size() &&
"Deserialized a declaration we shouldn't have");
}
if (LocalRedeclChains.empty())
return;
// Sort the local redeclarations map by the first declaration ID,
// since the reader will be performing binary searches on this information.
llvm::array_pod_sort(LocalRedeclsMap.begin(), LocalRedeclsMap.end());
// Emit the local redeclarations map.
using namespace llvm;
llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(LOCAL_REDECLARATIONS_MAP));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
RecordData Record;
Record.push_back(LOCAL_REDECLARATIONS_MAP);
Record.push_back(LocalRedeclsMap.size());
Stream.EmitRecordWithBlob(AbbrevID, Record,
reinterpret_cast<char*>(LocalRedeclsMap.data()),
LocalRedeclsMap.size() * sizeof(LocalRedeclarationsInfo));
// Emit the redeclaration chains.
Stream.EmitRecord(LOCAL_REDECLARATIONS, LocalRedeclChains);
}
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
void ASTWriter::WriteObjCCategories() {
llvm::SmallVector<ObjCCategoriesInfo, 2> CategoriesMap;
RecordData Categories;
for (unsigned I = 0, N = ObjCClassesWithCategories.size(); I != N; ++I) {
unsigned Size = 0;
unsigned StartIndex = Categories.size();
ObjCInterfaceDecl *Class = ObjCClassesWithCategories[I];
// Allocate space for the size.
Categories.push_back(0);
// Add the categories.
for (ObjCCategoryDecl *Cat = Class->getCategoryList();
Cat; Cat = Cat->getNextClassCategory(), ++Size) {
assert(getDeclID(Cat) != 0 && "Bogus category");
AddDeclRef(Cat, Categories);
}
// Update the size.
Categories[StartIndex] = Size;
// Record this interface -> category map.
ObjCCategoriesInfo CatInfo = { getDeclID(Class), StartIndex };
CategoriesMap.push_back(CatInfo);
}
// Sort the categories map by the definition ID, since the reader will be
// performing binary searches on this information.
llvm::array_pod_sort(CategoriesMap.begin(), CategoriesMap.end());
// Emit the categories map.
using namespace llvm;
llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(OBJC_CATEGORIES_MAP));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of entries
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned AbbrevID = Stream.EmitAbbrev(Abbrev);
RecordData Record;
Record.push_back(OBJC_CATEGORIES_MAP);
Record.push_back(CategoriesMap.size());
Stream.EmitRecordWithBlob(AbbrevID, Record,
reinterpret_cast<char*>(CategoriesMap.data()),
CategoriesMap.size() * sizeof(ObjCCategoriesInfo));
// Emit the category lists.
Stream.EmitRecord(OBJC_CATEGORIES, Categories);
}
Serialize the AST reader's mapping from canonical declarations to the set of (previously-canonical) declaration IDs to the module file, so that future AST reader instances that load the module know which declarations are merged. This is important in the fairly tricky case where a declaration of an entity, e.g., @class X; occurs before the import of a module that also declares that entity. We merge the declarations, and record the fact that the declaration of X loaded from the module was merged into the (now canonical) declaration of X that we parsed. llvm-svn: 147181
2011-12-23 05:40:42 +08:00
void ASTWriter::WriteMergedDecls() {
if (!Chain || Chain->MergedDecls.empty())
return;
RecordData Record;
for (ASTReader::MergedDeclsMap::iterator I = Chain->MergedDecls.begin(),
IEnd = Chain->MergedDecls.end();
I != IEnd; ++I) {
When we deserialize a declaration from a module file, allocate extra storage for the global declaration ID. Declarations that are parsed (rather than deserialized) are unaffected, so the number of declarations that pay this cost tends to be relatively small (since relatively few declarations are ever deserialized). This replaces a largish DenseMap within the AST reader. It's not strictly a win in terms of memory use---not every declaration was added to that DenseMap in the first place---but it's cleaner to have this information available for every deserialized declaration, so that future clients can rely on it. llvm-svn: 147617
2012-01-06 06:27:05 +08:00
DeclID CanonID = I->first->isFromASTFile()? I->first->getGlobalID()
Serialize the AST reader's mapping from canonical declarations to the set of (previously-canonical) declaration IDs to the module file, so that future AST reader instances that load the module know which declarations are merged. This is important in the fairly tricky case where a declaration of an entity, e.g., @class X; occurs before the import of a module that also declares that entity. We merge the declarations, and record the fact that the declaration of X loaded from the module was merged into the (now canonical) declaration of X that we parsed. llvm-svn: 147181
2011-12-23 05:40:42 +08:00
: getDeclID(I->first);
assert(CanonID && "Merged declaration not known?");
Record.push_back(CanonID);
Record.push_back(I->second.size());
Record.append(I->second.begin(), I->second.end());
}
Stream.EmitRecord(MERGED_DECLARATIONS, 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.
Inline storage of attributes in AttributedStmt. llvm-svn: 159925
2012-07-09 18:04:07 +08:00
void ASTWriter::WriteAttributes(ArrayRef<const Attr*> Attrs,
RecordDataImpl &Record) {
Read/write declaration attributes from/to PCH properly. Embed them in the declaration block instead of trying to create another block. The new block was messing with the assumption that after decls block comes the stmts block. Fixes http://llvm.org/PR8406 llvm-svn: 116737
2010-10-19 03:20:11 +08:00
Record.push_back(Attrs.size());
Inline storage of attributes in AttributedStmt. llvm-svn: 159925
2012-07-09 18:04:07 +08:00
for (ArrayRef<const Attr *>::iterator i = Attrs.begin(),
e = Attrs.end(); i != e; ++i){
const Attr *A = *i;
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
Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
Keep the source range of attributes. Depends on a llvm tablegen commit. llvm-svn: 139600
2011-09-14 00:05:58 +08:00
AddSourceRange(A->getRange(), Record);
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
}
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void ASTWriter::AddString(StringRef Str, RecordDataImpl &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());
}
Implement a new 'availability' attribute, that allows one to specify which versions of an OS provide a certain facility. For example, void foo() __attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6))); says that the function "foo" was introduced in 10.2, deprecated in 10.4, and completely obsoleted in 10.6. This attribute ties in with the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that we want to deploy back to Mac OS X 10.1). There are several concrete behaviors that this attribute enables, as illustrated with the function foo() above: - If we choose a deployment target >= Mac OS X 10.4, uses of "foo" will result in a deprecation warning, as if we had placed attribute((deprecated)) on it (but with a better diagnostic) - If we choose a deployment target >= Mac OS X 10.6, uses of "foo" will result in an "unavailable" warning (in C)/error (in C++), as if we had placed attribute((unavailable)) on it - If we choose a deployment target prior to 10.2, foo() is weak-imported (if it is a kind of entity that can be weak imported), as if we had placed the weak_import attribute on it. Naturally, there can be multiple availability attributes on a declaration, for different platforms; only the current platform matters when checking availability attributes. The only platforms this attribute currently works for are "ios" and "macosx", since we already have -mxxxx-version-min flags for them and we have experience there with macro tricks translating down to the deprecated/unavailable/weak_import attributes. The end goal is to open this up to other platforms, and even extension to other "platforms" that are really libraries (say, through a #pragma clang define_system), but that hasn't yet been designed and we may want to shake out more issues with this narrower problem first. Addresses <rdar://problem/6690412>. As a drive-by bug-fix, if an entity is both deprecated and unavailable, we only emit the "unavailable" diagnostic. llvm-svn: 128127
2011-03-23 08:50:03 +08:00
void ASTWriter::AddVersionTuple(const VersionTuple &Version,
RecordDataImpl &Record) {
Record.push_back(Version.getMajor());
if (llvm::Optional<unsigned> Minor = Version.getMinor())
Record.push_back(*Minor + 1);
else
Record.push_back(0);
if (llvm::Optional<unsigned> Subminor = Version.getSubminor())
Record.push_back(*Subminor + 1);
else
Record.push_back(0);
}
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)
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
: Stream(Stream), Context(0), PP(0), Chain(0), WritingModule(0),
[PCH] Make sure that all newly introduced visible decls in a DeclContext coming from an AST file are registered for serialization. A static data member instantiation of in a chained PCH could be missed when serializing decls; the result was that when emitting the visible decls map of its DeclContext, we would use a DeclID that was not actually emitted, leading to crashes or hangs. Fix this by making sure such decls are always registered for serialization. Also introduce extra sanity checks to make sure we don't register new declarations or types after we have serialized the types/decls block. rdar://11728990 llvm-svn: 159550
2012-07-03 03:19:01 +08:00
WritingAST(false), DoneWritingDeclsAndTypes(false),
ASTHasCompilerErrors(false),
Introduce a constant for the number of predefined declarations in an AST file, along with an enumeration naming those predefined declarations. No functionality change, but this will make it easier to introduce new predefined declarations, when/if we need them. llvm-svn: 136781
2011-08-04 00:05:40 +08:00
FirstDeclID(NUM_PREDEF_DECL_IDS), 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),
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID),
FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID),
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
FirstSubmoduleID(NUM_PREDEF_SUBMODULE_IDS),
NextSubmoduleID(FirstSubmoduleID),
Introduce local -> global selector ID mapping into the AST reader. Tested with the usual "gaps" method. llvm-svn: 136839
2011-08-04 07:28:44 +08:00
FirstSelectorID(NUM_PREDEF_SELECTOR_IDS), 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
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),
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
NumVisibleDeclContexts(0),
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
NextCXXBaseSpecifiersID(1),
Improvements to abbreviations for PCH which add support for EnumDecl, ObjCIvarDecl, TypedefDecl, VarDecl and FieldDecl and improve support for ParmVarDecl. llvm-svn: 132604
2011-06-04 07:11:16 +08:00
DeclParmVarAbbrev(0), DeclContextLexicalAbbrev(0),
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
DeclContextVisibleLookupAbbrev(0), UpdateVisibleAbbrev(0),
DeclRefExprAbbrev(0), CharacterLiteralAbbrev(0),
DeclRecordAbbrev(0), IntegerLiteralAbbrev(0),
Improvements to abbreviations for PCH which add support for EnumDecl, ObjCIvarDecl, TypedefDecl, VarDecl and FieldDecl and improve support for ParmVarDecl. llvm-svn: 132604
2011-06-04 07:11:16 +08:00
DeclTypedefAbbrev(0),
DeclVarAbbrev(0), DeclFieldAbbrev(0),
DeclEnumAbbrev(0), DeclObjCIvarAbbrev(0)
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
{
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
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
ASTWriter::~ASTWriter() {
for (FileDeclIDsTy::iterator
I = FileDeclIDs.begin(), E = FileDeclIDs.end(); I != E; ++I)
delete I->second;
}
[PCH] Remove the stat cache from the PCH file. The stat cache became essentially useless ever since we started validating all file entries in the PCH. But the motivating reason for removing it now is that it also affected correctness in this situation: -You have a header without include guards (using "#pragma once" or #import) -When creating the PCH: -The same header is referenced in an #include with different filename cases. -In the PCH, of course, we record only one file entry for the header file -But we cache in the PCH file the stat info for both filename cases -Then the source files are updated and the header file is updated in a way that its size and modification time are the same but its inode changes -When using the PCH: -We validate the headers, we check that header file and we create a file entry with its current inode -There's another #include with a filename with different case than the previously created file entry -In order to get its stat info we go through the cached stat info of the PCH and we receive the old inode -because of the different inodes, we think they are different files so we go ahead and include its contents. Removing the stat cache will potentially break clients that are attempting to use the stat cache as a way of avoiding having the actual input files available. If that use case is important, patches are welcome to bring it back in a way that will actually work correctly (i.e., emit a PCH that is self-contained, coping with literal strings, line/column computations, etc.). This fixes rdar://5502805 llvm-svn: 167172
2012-11-01 04:59:50 +08:00
void ASTWriter::WriteAST(Sema &SemaRef,
Allow resolving headers from a PCH even after headers+PCH were moved to another path. Store in PCH the directory that the PCH was originally created in. If a header file is not found at the path that we expect it to be and the PCH file was moved from its original location, try to resolve the file by assuming that header+PCH were moved together and the header is in the same place relative to the PCH. llvm-svn: 125576
2011-02-16 01:54:22 +08:00
const std::string &OutputFile,
[PCH] Mark a PCH file with a flag to indicate if the serialized AST had compiler errors or not. -Control whether ASTReader should reject such a PCH by a boolean flag at ASTReader's creation time. By default, such a PCH file will be rejected with an error when trying to load it. [libclang] Allow clang_saveTranslationUnit to create a PCH file even if compiler errors occurred. -Have libclang API calls accept a PCH that had compiler errors. The general idea is that we want libclang to stay functional even if a PCH had a compiler error. rdar://10976363. llvm-svn: 152192
2012-03-07 09:51:17 +08:00
Module *WritingModule, StringRef isysroot,
bool hasErrors) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
WritingAST = true;
[PCH] Mark a PCH file with a flag to indicate if the serialized AST had compiler errors or not. -Control whether ASTReader should reject such a PCH by a boolean flag at ASTReader's creation time. By default, such a PCH file will be rejected with an error when trying to load it. [libclang] Allow clang_saveTranslationUnit to create a PCH file even if compiler errors occurred. -Have libclang API calls accept a PCH that had compiler errors. The general idea is that we want libclang to stay functional even if a PCH had a compiler error. rdar://10976363. llvm-svn: 152192
2012-03-07 09:51:17 +08:00
ASTHasCompilerErrors = hasErrors;
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
Migrate the serialization of ASTContext's AutoDeduceTy and AutoRRefDeductTy from the "special types" block to predefined types. The latter behaves better when loading multiple AST files. llvm-svn: 137120
2011-08-09 23:13:55 +08:00
Context = &SemaRef.Context;
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
PP = &SemaRef.PP;
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
this->WritingModule = WritingModule;
[PCH] Remove the stat cache from the PCH file. The stat cache became essentially useless ever since we started validating all file entries in the PCH. But the motivating reason for removing it now is that it also affected correctness in this situation: -You have a header without include guards (using "#pragma once" or #import) -When creating the PCH: -The same header is referenced in an #include with different filename cases. -In the PCH, of course, we record only one file entry for the header file -But we cache in the PCH file the stat info for both filename cases -Then the source files are updated and the header file is updated in a way that its size and modification time are the same but its inode changes -When using the PCH: -We validate the headers, we check that header file and we create a file entry with its current inode -There's another #include with a filename with different case than the previously created file entry -In order to get its stat info we go through the cached stat info of the PCH and we receive the old inode -because of the different inodes, we think they are different files so we go ahead and include its contents. Removing the stat cache will potentially break clients that are attempting to use the stat cache as a way of avoiding having the actual input files available. If that use case is important, patches are welcome to bring it back in a way that will actually work correctly (i.e., emit a PCH that is self-contained, coping with literal strings, line/column computations, etc.). This fixes rdar://5502805 llvm-svn: 167172
2012-11-01 04:59:50 +08:00
WriteASTCore(SemaRef, isysroot, OutputFile, WritingModule);
Migrate the serialization of ASTContext's AutoDeduceTy and AutoRRefDeductTy from the "special types" block to predefined types. The latter behaves better when loading multiple AST files. llvm-svn: 137120
2011-08-09 23:13:55 +08:00
Context = 0;
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +08:00
PP = 0;
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
this->WritingModule = 0;
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
WritingAST = false;
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
}
Switch Sema::UnusedFileScopedDecls over to a LazyVector. - Added LazyVector::erase() to support this use case. - Factored out the LazyDecl-of-Decls to RecordData translation in the ASTWriter. There is still a pile of code duplication here to eliminate. llvm-svn: 136270
2011-07-28 05:45:57 +08:00
template<typename Vector>
static void AddLazyVectorDecls(ASTWriter &Writer, Vector &Vec,
ASTWriter::RecordData &Record) {
for (typename Vector::iterator I = Vec.begin(0, true), E = Vec.end();
I != E; ++I) {
Writer.AddDeclRef(*I, Record);
}
}
[PCH] Remove the stat cache from the PCH file. The stat cache became essentially useless ever since we started validating all file entries in the PCH. But the motivating reason for removing it now is that it also affected correctness in this situation: -You have a header without include guards (using "#pragma once" or #import) -When creating the PCH: -The same header is referenced in an #include with different filename cases. -In the PCH, of course, we record only one file entry for the header file -But we cache in the PCH file the stat info for both filename cases -Then the source files are updated and the header file is updated in a way that its size and modification time are the same but its inode changes -When using the PCH: -We validate the headers, we check that header file and we create a file entry with its current inode -There's another #include with a filename with different case than the previously created file entry -In order to get its stat info we go through the cached stat info of the PCH and we receive the old inode -because of the different inodes, we think they are different files so we go ahead and include its contents. Removing the stat cache will potentially break clients that are attempting to use the stat cache as a way of avoiding having the actual input files available. If that use case is important, patches are welcome to bring it back in a way that will actually work correctly (i.e., emit a PCH that is self-contained, coping with literal strings, line/column computations, etc.). This fixes rdar://5502805 llvm-svn: 167172
2012-11-01 04:59:50 +08:00
void ASTWriter::WriteASTCore(Sema &SemaRef,
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
StringRef isysroot,
When writing a module file, pass the module through to the AST writer. No functionality change. llvm-svn: 145479
2011-11-30 12:39:39 +08:00
const std::string &OutputFile,
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
Module *WritingModule) {
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;
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
// Make sure that the AST reader knows to finalize itself.
if (Chain)
Chain->finalizeForWriting();
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;
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
// Set up predefined declaration IDs.
DeclIDs[Context.getTranslationUnitDecl()] = PREDEF_DECL_TRANSLATION_UNIT_ID;
Move the creation of the predefined typedef for Objective-C's 'id' type over into the AST context, then make that declaration a predefined declaration in the AST format. This ensures that different AST files will at least agree on the (global) declaration ID for 'id', and eliminates one of the "special" types in the AST file format. llvm-svn: 137429
2011-08-12 13:46:01 +08:00
if (Context.ObjCIdDecl)
DeclIDs[Context.ObjCIdDecl] = PREDEF_DECL_OBJC_ID_ID;
Switch the Objective-C 'SEL' type over to a predefined type in the AST file format, lazily generating the actual declaration in ASTContext as needed. llvm-svn: 137434
2011-08-12 14:17:30 +08:00
if (Context.ObjCSelDecl)
DeclIDs[Context.ObjCSelDecl] = PREDEF_DECL_OBJC_SEL_ID;
Switch the Objective-C 'Class' type over to a predefined type in the AST file format, lazily generating the actual declaration in ASTContext as needed. llvm-svn: 137431
2011-08-12 13:59:41 +08:00
if (Context.ObjCClassDecl)
DeclIDs[Context.ObjCClassDecl] = PREDEF_DECL_OBJC_CLASS_ID;
Delay the creation of the built-in Objective-C class 'Protocol' by moving it from a "special type" to a predefined declaration, as we do for id, Class, and SEL. llvm-svn: 148313
2012-01-18 02:09:05 +08:00
if (Context.ObjCProtocolClassDecl)
DeclIDs[Context.ObjCProtocolClassDecl] = PREDEF_DECL_OBJC_PROTOCOL_ID;
Switch the __int128_t and __uint128_t types over to predefined types in the AST format, which are built lazily by the ASTContext when requested. llvm-svn: 137437
2011-08-12 14:49:56 +08:00
if (Context.Int128Decl)
DeclIDs[Context.Int128Decl] = PREDEF_DECL_INT_128_ID;
if (Context.UInt128Decl)
DeclIDs[Context.UInt128Decl] = PREDEF_DECL_UNSIGNED_INT_128_ID;
Implement the Objective-C 'instancetype' type, which is an alias of 'id' that can be used (only!) via a contextual keyword as the result type of an Objective-C message send. 'instancetype' then gives the method a related result type, which we have already been inferring for a variety of methods (new, alloc, init, self, retain). Addresses <rdar://problem/9267640>. llvm-svn: 139275
2011-09-08 09:46:34 +08:00
if (Context.ObjCInstanceTypeDecl)
DeclIDs[Context.ObjCInstanceTypeDecl] = PREDEF_DECL_OBJC_INSTANCETYPE_ID;
Explicitly build __builtin_va_list. The target specific __builtin_va_list types are now explicitly built instead of injecting strings into the preprocessor input. llvm-svn: 158592
2012-06-16 11:34:49 +08:00
if (Context.BuiltinVaListDecl)
DeclIDs[Context.getBuiltinVaListDecl()] = PREDEF_DECL_BUILTIN_VA_LIST_ID;
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
if (!Chain) {
// Make sure that we emit IdentifierInfos (and any attached
// declarations) for builtins. We don't need to do this when we're
// emitting chained PCH files, because all of the builtins will be
// in the original PCH file.
// FIXME: Modules won't like this at all.
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
IdentifierTable &Table = PP.getIdentifierTable();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<const char *, 32> BuiltinNames;
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
Context.BuiltinInfo.GetBuiltinNames(BuiltinNames,
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
Context.getLangOpts().NoBuiltin);
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
for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I)
getIdentifierRef(&Table.get(BuiltinNames[I]));
}
Make the loading of information attached to an IdentifierInfo from an AST file more lazy, so that we don't eagerly load that information for all known identifiers each time a new AST file is loaded. The eager reloading made some sense in the context of precompiled headers, since very few identifiers were defined before PCH load time. With modules, however, a huge amount of code can get parsed before we see an @import, so laziness becomes important here. The approach taken to make this information lazy is fairly simple: when we load a new AST file, we mark all of the existing identifiers as being out-of-date. Whenever we want to access information that may come from an AST (e.g., whether the identifier has a macro definition, or what top-level declarations have that name), we check the out-of-date bit and, if it's set, ask the AST reader to update the IdentifierInfo from the AST files. The update is a merge, and we now take care to merge declarations before/after imports with declarations from multiple imports. The results of this optimization are fairly dramatic. On a small application that brings in 14 non-trivial modules, this takes modules from being > 3x slower than a "perfect" PCH file down to 30% slower for a full rebuild. A partial rebuild (where the PCH file or modules can be re-used) is down to 7% slower. Making the PCH file just a little imperfect (e.g., adding two smallish modules used by a bunch of .m files that aren't in the PCH file) tips the scales in favor of the modules approach, with 24% faster partial rebuilds. This is just a first step; the lazy scheme could possibly be improved by adding versioning, so we don't search into modules we already searched. Moreover, we'll need similar lazy schemes for all of the other lookup data structures, such as DeclContexts. llvm-svn: 143100
2011-10-27 17:33:13 +08:00
// If there are any out-of-date identifiers, bring them up to date.
if (ExternalPreprocessorSource *ExtSource = PP.getExternalSource()) {
for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
IDEnd = PP.getIdentifierTable().end();
ID != IDEnd; ++ID)
if (ID->second->isOutOfDate())
ExtSource->updateOutOfDateIdentifier(*ID->second);
}
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;
Switch Sema::UnusedFileScopedDecls over to a LazyVector. - Added LazyVector::erase() to support this use case. - Factored out the LazyDecl-of-Decls to RecordData translation in the ASTWriter. There is still a pile of code duplication here to eliminate. llvm-svn: 136270
2011-07-28 05:45:57 +08:00
AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
Introduce a new data structure, LazyVector, which is a vector whose contents are lazily loaded on demand from an external source (e.g., an ExternalASTSource or ExternalSemaSource). The "loaded" entities are kept separate from the "local" entities, so that the two can grow independently. Switch Sema::TentativeDefinitions from a normal vector that is eagerly populated by the ASTReader into one of these LazyVectors, making the ASTReader a bit more like me (i.e., lazy). llvm-svn: 136262
2011-07-28 04:58:46 +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;
Switch Sema::UnusedFileScopedDecls over to a LazyVector. - Added LazyVector::erase() to support this use case. - Factored out the LazyDecl-of-Decls to RecordData translation in the ASTWriter. There is still a pile of code duplication here to eliminate. llvm-svn: 136270
2011-07-28 05:45:57 +08:00
AddLazyVectorDecls(*this, SemaRef.UnusedFileScopedDecls,
UnusedFileScopedDecls);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Build a record containing all of the delegating constructors we still need
// to resolve.
there i fixed it Increase robustness of the delegating constructor cycle detection mechanism. No more infinite loops on invalid or logic errors leading to false results. Ensure that this is maintained correctly accross serialization. llvm-svn: 130887
2011-05-05 07:29:54 +08:00
RecordData DelegatingCtorDecls;
Turn Sema::DelegatingCtorDecls into a LazyVector. llvm-svn: 136273
2011-07-28 05:57:17 +08:00
AddLazyVectorDecls(*this, SemaRef.DelegatingCtorDecls, DelegatingCtorDecls);
there i fixed it Increase robustness of the delegating constructor cycle detection mechanism. No more infinite loops on invalid or logic errors leading to false results. Ensure that this is maintained correctly accross serialization. llvm-svn: 130887
2011-05-05 07:29:54 +08:00
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Write the set of weak, undeclared identifiers. We always write the
// entire table, since later PCH files in a PCH chain are only interested in
// the results at the end of the chain.
Support #pragma weak for PCH. llvm-svn: 110323
2010-08-05 17:48:08 +08:00
RecordData WeakUndeclaredIdentifiers;
if (!SemaRef.WeakUndeclaredIdentifiers.empty()) {
Make Sema::WeakUndeclaredIdentifiers lazily deserialized. llvm-svn: 136368
2011-07-29 02:09:57 +08:00
for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
Support #pragma weak for PCH. llvm-svn: 110323
2010-08-05 17:48:08 +08:00
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();
Make Sema::LocallyScopedExternalDecls lazily deserialized. In theory, we could turn this into an on-disk hash table so we don't load the whole thing the first time we need it. However, it tends to be very, very small (i.e., empty) for most precompiled headers, so it isn't all that interesting. llvm-svn: 136352
2011-07-28 22:20:37 +08:00
TD != TDEnd; ++TD) {
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!TD->second->isFromASTFile())
Make Sema::LocallyScopedExternalDecls lazily deserialized. In theory, we could turn this into an on-disk hash table so we don't load the whole thing the first time we need it. However, it tends to be very, very small (i.e., empty) for most precompiled headers, so it isn't all that interesting. llvm-svn: 136352
2011-07-28 22:20:37 +08:00
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;
Switch Sema::ExtVectorDecls over to LazyVector. llvm-svn: 136314
2011-07-28 08:39:29 +08:00
AddLazyVectorDecls(*this, SemaRef.ExtVectorDecls, ExtVectorDecls);
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
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()) {
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;
Switch Sema::DynamicClasses over to LazyVector llvm-svn: 136317
2011-07-28 08:53:40 +08:00
AddLazyVectorDecls(*this, SemaRef.DynamicClasses, 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
// 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);
}
AST, Sema, Serialization: keep track of cudaConfigureCall llvm-svn: 125216
2011-02-10 05:04:32 +08:00
RecordData CUDASpecialDeclRefs;
if (Context.getcudaConfigureCallDecl()) {
AddDeclRef(Context.getcudaConfigureCallDecl(), CUDASpecialDeclRefs);
}
Add support for C++ namespace-aware typo correction, e.g., correcting vector<int> to std::vector<int> Patch by Kaelyn Uhrain, with minor tweaks + PCH support from me. Fixes PR5776/<rdar://problem/8652971>. Thanks Kaelyn! llvm-svn: 134007
2011-06-29 00:20:02 +08:00
// Build a record containing all of the known namespaces.
RecordData KnownNamespaces;
for (llvm::DenseMap<NamespaceDecl*, bool>::iterator
I = SemaRef.KnownNamespaces.begin(),
IEnd = SemaRef.KnownNamespaces.end();
I != IEnd; ++I) {
if (!I->second)
AddDeclRef(I->first, KnownNamespaces);
}
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +08:00
// Write the control block
(De-)serialize header search options. llvm-svn: 166586
2012-10-25 00:50:34 +08:00
WriteControlBlock(PP, Context, isysroot, OutputFile);
Start factoring the on-disk records for an AST file into a control block, which stores information about how the AST file to generated, from the AST block, which stores the actual serialized AST. The information in the control block should be enough to determine whether the AST file is up-to-date and compatible with the current translation unit, and reading it should not cause any side effects that aren't easy to undo. That way, we can back out from an attempt to read an incompatible or out-of-date AST file. Note that there is still more factoring to do. In particular, information about the source files used to generate the AST file (along with their time stamps, sizes, etc.) still resides in the source manager block. llvm-svn: 166166
2012-10-18 13:31:06 +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 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);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Create a lexical update block containing all of the declarations in the
// translation unit that do not come from other AST files.
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
const TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
SmallVector<KindDeclIDPair, 64> NewGlobalDecls;
for (DeclContext::decl_iterator I = TU->noload_decls_begin(),
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
E = TU->noload_decls_end();
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
I != E; ++I) {
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!(*I)->isFromASTFile())
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I)));
}
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
llvm::BitCodeAbbrev *Abv = new llvm::BitCodeAbbrev();
Abv->Add(llvm::BitCodeAbbrevOp(TU_UPDATE_LEXICAL));
Abv->Add(llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob));
unsigned TuUpdateLexicalAbbrev = Stream.EmitAbbrev(Abv);
Record.clear();
Record.push_back(TU_UPDATE_LEXICAL);
Stream.EmitRecordWithBlob(TuUpdateLexicalAbbrev, Record,
data(NewGlobalDecls));
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// And a visible updates block for the translation unit.
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
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);
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// If the translation unit has an anonymous namespace, and we don't already
// have an update block for it, write it as an update block.
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
if (NamespaceDecl *NS = TU->getAnonymousNamespace()) {
ASTWriter::UpdateRecord &Record = DeclUpdates[TU];
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
if (Record.empty()) {
Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE);
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
Record.push_back(reinterpret_cast<uint64_t>(NS));
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
}
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
}
[PCH] Make sure that all newly introduced visible decls in a DeclContext coming from an AST file are registered for serialization. A static data member instantiation of in a chained PCH could be missed when serializing decls; the result was that when emitting the visible decls map of its DeclContext, we would use a DeclID that was not actually emitted, leading to crashes or hangs. Fix this by making sure such decls are always registered for serialization. Also introduce extra sanity checks to make sure we don't register new declarations or types after we have serialized the types/decls block. rdar://11728990 llvm-svn: 159550
2012-07-03 03:19:01 +08:00
// Make sure visible decls, added to DeclContexts previously loaded from
// an AST file, are registered for serialization.
for (SmallVector<const Decl *, 16>::iterator
I = UpdatingVisibleDecls.begin(),
E = UpdatingVisibleDecls.end(); I != E; ++I) {
GetDeclRef(*I);
}
[PCH] In ASTWriter::WriteChainedObjCCategories use getDeclID since the decls should have been already emitted. llvm-svn: 144519
2011-11-14 12:52:24 +08:00
// Resolve any declaration pointers within the declaration updates block.
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
ResolveDeclUpdatesBlocks();
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Form the record of special types.
RecordData SpecialTypes;
AddTypeRef(Context.getRawCFConstantStringType(), SpecialTypes);
AddTypeRef(Context.getFILEType(), SpecialTypes);
AddTypeRef(Context.getjmp_bufType(), SpecialTypes);
AddTypeRef(Context.getsigjmp_bufType(), SpecialTypes);
AddTypeRef(Context.ObjCIdRedefinitionType, SpecialTypes);
AddTypeRef(Context.ObjCClassRedefinitionType, SpecialTypes);
AddTypeRef(Context.ObjCSelRedefinitionType, SpecialTypes);
Fix the signature of the getcontext builtin. Patch by Dimitry Andric. llvm-svn: 144505
2011-11-14 05:51:09 +08:00
AddTypeRef(Context.getucontext_tType(), SpecialTypes);
Infer the submodule ID for a given declaration based on the location of that declaration, and encode the submodule ID in each declaration stored in an AST file. llvm-svn: 145555
2011-12-01 10:07:58 +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.
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
Stream.EnterSubblock(DECLTYPES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
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();
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
for (DeclsToRewriteTy::iterator I = DeclsToRewrite.begin(),
E = DeclsToRewrite.end();
I != E; ++I)
DeclTypesToEmit.push(const_cast<Decl*>(*I));
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
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
[PCH] Make sure that all newly introduced visible decls in a DeclContext coming from an AST file are registered for serialization. A static data member instantiation of in a chained PCH could be missed when serializing decls; the result was that when emitting the visible decls map of its DeclContext, we would use a DeclID that was not actually emitted, leading to crashes or hangs. Fix this by making sure such decls are always registered for serialization. Also introduce extra sanity checks to make sure we don't register new declarations or types after we have serialized the types/decls block. rdar://11728990 llvm-svn: 159550
2012-07-03 03:19:01 +08:00
DoneWritingDeclsAndTypes = true;
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
WriteFileDeclIDsMap();
WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
Structured comment parsing, first step. * Retain comments in the AST * Serialize/deserialize comments * Find comments attached to a certain Decl * Expose raw comment text and SourceRange via libclang llvm-svn: 158771
2012-06-20 08:34:58 +08:00
WriteComments();
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
if (Chain) {
// Write the mapping information describing our module dependencies and how
// each of those modules were mapped into our own offset/ID space, so that
// the reader can build the appropriate mapping to its own offset/ID space.
// The map consists solely of a blob with the following format:
// *(module-name-len:i16 module-name:len*i8
// source-location-offset:i32
// identifier-id:i32
// preprocessed-entity-id:i32
// macro-definition-id:i32
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
// submodule-id:i32
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
// selector-id:i32
// declaration-id:i32
// c++-base-specifiers-id:i32
// type-id:i32)
//
llvm::BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(MODULE_OFFSET_MAP));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(Abbrev);
Basic: import SmallString<> into clang namespace (I was going to fix the TODO about DenseMap too, but that would break self-host right now. See PR11922.) llvm-svn: 149799
2012-02-05 10:13:05 +08:00
SmallString<2048> Buffer;
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
{
llvm::raw_svector_ostream Out(Buffer);
for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
Implement (de-)serialization of the set of exported modules in a module map. llvm-svn: 145695
2011-12-03 02:58:38 +08:00
MEnd = Chain->ModuleMgr.end();
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
M != MEnd; ++M) {
StringRef FileName = (*M)->FileName;
io::Emit16(Out, FileName.size());
Out.write(FileName.data(), FileName.size());
io::Emit32(Out, (*M)->SLocEntryBaseOffset);
io::Emit32(Out, (*M)->BaseIdentifierID);
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
io::Emit32(Out, (*M)->BaseMacroID);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
io::Emit32(Out, (*M)->BasePreprocessedEntityID);
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
io::Emit32(Out, (*M)->BaseSubmoduleID);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
io::Emit32(Out, (*M)->BaseSelectorID);
io::Emit32(Out, (*M)->BaseDeclID);
io::Emit32(Out, (*M)->BaseTypeIndex);
}
}
Record.clear();
Record.push_back(MODULE_OFFSET_MAP);
Stream.EmitRecordWithBlob(ModuleOffsetMapAbbrev, Record,
Buffer.data(), Buffer.size());
}
When writing a module file, pass the module through to the AST writer. No functionality change. llvm-svn: 145479
2011-11-30 12:39:39 +08:00
WritePreprocessor(PP, WritingModule != 0);
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
WriteHeaderSearch(PP.getHeaderSearchInfo(), isysroot);
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);
When writing a module file, pass the module through to the AST writer. No functionality change. llvm-svn: 145479
2011-11-30 12:39:39 +08:00
WriteIdentifierTable(PP, SemaRef.IdResolver, WritingModule != 0);
Serialization/deserialization support for floating point #pragma options, enabled OpenCL extensions and default FP_CONTRACT setting. llvm-svn: 125589
2011-02-16 03:46:30 +08:00
WriteFPPragmaOptions(SemaRef.getFPOptions());
WriteOpenCLExtensions(SemaRef);
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();
Properly propagate #pragma diagnostic mappings from PCH but not command-line warning flags. Addresses rdar://8435969&8852495 llvm-svn: 123462
2011-01-15 04:54:07 +08:00
WritePragmaDiagnosticMappings(Context.getDiagnostics());
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
Write CXX base specifier offsets for chained ASTs. llvm-svn: 127126
2011-03-07 02:41:18 +08:00
WriteCXXBaseSpecifiersOffsets();
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
Implement inferred submodules support, which (when requested) implicitly generates submodules corresponding to the headers that fall within a module. llvm-svn: 145887
2011-12-06 09:10:29 +08:00
// If we're emitting a module, write out the submodule information.
if (WritingModule)
WriteSubmodules(WritingModule);
Implement a proper local -> global type ID remapping scheme in the AST reader. This scheme permits an AST file to be loaded with its type IDs shifted anywhere in the type ID space. At present, the type indices are still allocated in the same boring way they always have been, just by adding up the number of types in each PCH file within the chain. However, I've done testing with this patch by randomly sliding the base indices at load time, to ensure that remapping is occurring as expected. I may eventually formalize this in some testing flag, but loading multiple (non-chained) AST files at once will eventually exercise the same code. There is one known problem with this patch, which involves name lookup of operator names (e.g., "x.operator int*()") in cases where multiple PCH files in the chain. The hash function itself depends on having a stable type ID, which doesn't happen with chained PCH and *certainly* doesn't happen when sliding type IDs around. We'll need another approach. I'll tackle that next. llvm-svn: 136693
2011-08-03 00:26:37 +08:00
Stream.EmitRecord(SPECIAL_TYPES, SpecialTypes);
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);
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Write the record containing CUDA-specific declaration references.
if (!CUDASpecialDeclRefs.empty())
Stream.EmitRecord(CUDA_SPECIAL_DECL_REFS, CUDASpecialDeclRefs);
there i fixed it Increase robustness of the delegating constructor cycle detection mechanism. No more infinite loops on invalid or logic errors leading to false results. Ensure that this is maintained correctly accross serialization. llvm-svn: 130887
2011-05-05 07:29:54 +08:00
// Write the delegating constructors.
if (!DelegatingCtorDecls.empty())
Stream.EmitRecord(DELEGATING_CTORS, DelegatingCtorDecls);
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
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Write the known namespaces.
if (!KnownNamespaces.empty())
Stream.EmitRecord(KNOWN_NAMESPACES, KnownNamespaces);
// Write the visible updates to DeclContexts.
Use the ASTMutationListener to track when a named decl gets added to a DeclContext, meaning we need to rewrite its name lookup table in a chained PCH. llvm-svn: 117536
2010-10-28 15:38:51 +08:00
for (llvm::SmallPtrSet<const DeclContext *, 16>::iterator
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
I = UpdatedDeclContexts.begin(),
E = UpdatedDeclContexts.end();
I != E; ++I)
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
WriteDeclContextVisibleUpdate(*I);
Module files representing actual modules don't need to know the set of modules they import, since that information isn't actually used. Drop it from the AST file llvm-svn: 145738
2011-12-03 09:15:29 +08:00
if (!WritingModule) {
// Write the submodules that were imported, if any.
RecordData ImportedModules;
for (ASTContext::import_iterator I = Context.local_import_begin(),
IEnd = Context.local_import_end();
I != IEnd; ++I) {
assert(SubmoduleIDs.find(I->getImportedModule()) != SubmoduleIDs.end());
ImportedModules.push_back(SubmoduleIDs[I->getImportedModule()]);
}
if (!ImportedModules.empty()) {
// Sort module IDs.
llvm::array_pod_sort(ImportedModules.begin(), ImportedModules.end());
// Unique module IDs.
ImportedModules.erase(std::unique(ImportedModules.begin(),
ImportedModules.end()),
ImportedModules.end());
Stream.EmitRecord(IMPORTED_MODULES, ImportedModules);
}
Implement support for precompiled headers, preambles, and serialized "main" files that import modules. When loading any of these kinds of AST files, we make the modules that were imported visible into the translation unit that loaded the PCH file or preamble. llvm-svn: 145737
2011-12-03 08:59:55 +08:00
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
WriteMacroUpdates();
Some method renaming, no functionality change. llvm-svn: 117237
2010-10-25 01:26:43 +08:00
WriteDeclUpdatesBlocks();
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
WriteDeclReplacementsBlock();
Serialize the AST reader's mapping from canonical declarations to the set of (previously-canonical) declaration IDs to the module file, so that future AST reader instances that load the module know which declarations are merged. This is important in the fairly tricky case where a declaration of an entity, e.g., @class X; occurs before the import of a module that also declares that entity. We merge the declarations, and record the fact that the declaration of X loaded from the module was merged into the (now canonical) declaration of X that we parsed. llvm-svn: 147181
2011-12-23 05:40:42 +08:00
WriteMergedDecls();
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
WriteRedeclarations();
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
WriteObjCCategories();
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
Collapse ASTWriter::WriteASTChain into ASTWriter::WriteASTCore, eliminating a pile of redundant code (and probably some bugs in the process). The variation between chained and non-chained PCH is fairly small now anyway. llvm-svn: 137410
2011-08-12 09:39:19 +08:00
// Some simple statistics
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);
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();
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
void ASTWriter::WriteMacroUpdates() {
if (MacroUpdates.empty())
return;
RecordData Record;
for (MacroUpdatesMap::iterator I = MacroUpdates.begin(),
E = MacroUpdates.end();
I != E; ++I) {
addMacroRef(I->first, Record);
AddSourceLocation(I->second.UndefLoc, Record);
Track which particular submodule #undef's a macro, so that the actual #undef only occurs if that submodule is imported. llvm-svn: 165773
2012-10-12 08:16:50 +08:00
Record.push_back(inferSubmoduleIDFromLocation(I->second.UndefLoc));
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
}
Stream.EmitRecord(MACRO_UPDATES, Record);
}
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
/// \brief Go through the declaration update blocks and resolve declaration
/// pointers into declaration IDs.
void ASTWriter::ResolveDeclUpdatesBlocks() {
for (DeclUpdateMap::iterator
I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) {
const Decl *D = I->first;
UpdateRecord &URec = I->second;
[PCH] When completing an objc forward reference, do not serialize the chain of its categories because it is going to be rewritten (and the chain will be serialized again), otherwise we may form a cycle in its categories list when deserializing. Also introduce ASTMutationListener::CompletedObjCForwardRef to notify that a forward reference was completed; using Decl's isChangedSinceDeserialization/setChangedSinceDeserialization is bug inducing and kinda gross, we should phase it out. Fixes infinite loop in rdar://10418538. llvm-svn: 144465
2011-11-13 05:07:46 +08:00
if (isRewritten(D))
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
continue; // The decl will be written completely
unsigned Idx = 0, N = URec.size();
while (Idx < N) {
switch ((DeclUpdateKind)URec[Idx++]) {
case UPD_CXX_ADDED_IMPLICIT_MEMBER:
case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE:
URec[Idx] = GetDeclRef(reinterpret_cast<Decl *>(URec[Idx]));
++Idx;
break;
case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
++Idx;
break;
}
}
}
}
Some method renaming, no functionality change. llvm-svn: 117237
2010-10-25 01:26:43 +08:00
void ASTWriter::WriteDeclUpdatesBlocks() {
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
if (DeclUpdates.empty())
return;
RecordData OffsetsRecord;
Introduce additional abbreviations into the AST writer for DeclRefExprs, IntegerLiterals, and others, reducing Cocoa PCH size by ~1% and C++ header size by ~2.5%. From Jonathan Turner! llvm-svn: 132528
2011-06-03 10:27:19 +08:00
Stream.EnterSubblock(DECL_UPDATES_BLOCK_ID, NUM_ALLOWED_ABBREVS_SIZE);
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
for (DeclUpdateMap::iterator
I = DeclUpdates.begin(), E = DeclUpdates.end(); I != E; ++I) {
const Decl *D = I->first;
UpdateRecord &URec = I->second;
[PCH] When completing an objc forward reference, do not serialize the chain of its categories because it is going to be rewritten (and the chain will be serialized again), otherwise we may form a cycle in its categories list when deserializing. Also introduce ASTMutationListener::CompletedObjCForwardRef to notify that a forward reference was completed; using Decl's isChangedSinceDeserialization/setChangedSinceDeserialization is bug inducing and kinda gross, we should phase it out. Fixes infinite loop in rdar://10418538. llvm-svn: 144465
2011-11-13 05:07:46 +08:00
if (isRewritten(D))
Introduce a DeclsToRewrite field in ASTWrite, used for collecting the decls that will be replaced in the chained PCH. llvm-svn: 117238
2010-10-25 01:26:46 +08:00
continue; // The decl will be written completely,no need to store updates.
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
uint64_t Offset = Stream.GetCurrentBitNo();
Stream.EmitRecord(DECL_UPDATES, URec);
OffsetsRecord.push_back(GetDeclRef(D));
OffsetsRecord.push_back(Offset);
}
Stream.ExitBlock();
Stream.EmitRecord(DECL_UPDATE_OFFSETS, OffsetsRecord);
}
Some method renaming, no functionality change. llvm-svn: 117237
2010-10-25 01:26:43 +08:00
void ASTWriter::WriteDeclReplacementsBlock() {
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;
[PCH] Now that we store the location of a decl outside its record make sure that we keep track of locations of replaced decls as well. llvm-svn: 143341
2011-10-31 15:20:15 +08:00
for (SmallVector<ReplacedDeclInfo, 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) {
[PCH] Now that we store the location of a decl outside its record make sure that we keep track of locations of replaced decls as well. llvm-svn: 143341
2011-10-31 15:20:15 +08:00
Record.push_back(I->ID);
Record.push_back(I->Offset);
Record.push_back(I->Loc);
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 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
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &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());
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &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);
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordDataImpl &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
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordDataImpl &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);
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record) {
Add PCH support for PredefinedExpr and FloatingLiteral expressions llvm-svn: 69084
2009-04-15 05:55:33 +08:00
AddAPInt(Value.bitcastToAPInt(), Record);
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &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));
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
void ASTWriter::addMacroRef(MacroInfo *MI, RecordDataImpl &Record) {
Record.push_back(getMacroRef(MI));
}
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
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
MacroID ASTWriter::getMacroRef(MacroInfo *MI) {
// Don't emit builtin macros like __LINE__ to the AST file unless they
// have been redefined by the header (in which case they are not
// isBuiltinMacro).
if (MI == 0 || MI->isBuiltinMacro())
return 0;
MacroID &ID = MacroIDs[MI];
if (ID == 0)
ID = NextMacroID++;
return ID;
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddSelectorRef(const Selector SelRef, RecordDataImpl &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
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
AddDeclRef(Temp->getDestructor(), Record);
}
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
void ASTWriter::AddCXXBaseSpecifiersRef(CXXBaseSpecifier const *Bases,
CXXBaseSpecifier const *BasesEnd,
RecordDataImpl &Record) {
assert(Bases != BasesEnd && "Empty base-specifier sets are not recorded");
CXXBaseSpecifiersToWrite.push_back(
QueuedCXXBaseSpecifiers(NextCXXBaseSpecifiersID,
Bases, BasesEnd));
Record.push_back(NextCXXBaseSpecifiersID++);
}
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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
-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
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:
Push nested-name-specifier source location information into template template arguments. I believe that this is the last place in the AST where we were storing a source range for a nested-name-specifier rather than a proper nested-name-specifier location structure. (Yay!) There is still a lot of cleanup to do in the TreeTransform, which doesn't take advantage of nested-name-specifiers with source-location information everywhere it could. llvm-svn: 126844
2011-03-03 01:09:35 +08:00
AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
AddSourceLocation(Arg.getTemplateNameLoc(), Record);
break;
case TemplateArgument::TemplateExpansion:
Push nested-name-specifier source location information into template template arguments. I believe that this is the last place in the AST where we were storing a source range for a nested-name-specifier rather than a proper nested-name-specifier location structure. (Yay!) There is still a lot of cleanup to do in the TreeTransform, which doesn't take advantage of nested-name-specifiers with source-location information everywhere it could. llvm-svn: 126844
2011-03-03 01:09:35 +08:00
AddNestedNameSpecifierLoc(Arg.getTemplateQualifierLoc(), Record);
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
AddSourceLocation(Arg.getTemplateNameLoc(), Record);
Add semantic analysis for the creation of and an AST representation for template template argument pack expansions. This allows fun such as: template<template<class> class ...> struct apply_impl { /*...*/ }; template<template<class> class ...Metafunctions> struct apply { typedef typename apply_impl<Metafunctions...>::type type; }; However, neither template argument deduction nor template instantiation is implemented for template template argument packs, so this functionality isn't useful yet. I'll probably replace the encoding of template template argument pack expansions in TemplateArgument so that it's harder to accidentally forget about the expansion. However, this is a step in the right general direction. llvm-svn: 122890
2011-01-06 01:40:24 +08:00
AddSourceLocation(Arg.getTemplateEllipsisLoc(), 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:
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
case TemplateArgument::NullPtr:
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::Pack:
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
// FIXME: Is this right?
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;
}
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
-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
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);
}
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo,
RecordDataImpl &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;
}
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
AddTypeLoc(TInfo->getTypeLoc(), Record);
}
void ASTWriter::AddTypeLoc(TypeLoc TL, RecordDataImpl &Record) {
AddTypeRef(TL.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);
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
for (; !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
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddTypeRef(QualType T, RecordDataImpl &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));
}
Migrate the serialization of ASTContext's AutoDeduceTy and AutoRRefDeductTy from the "special types" block to predefined types. The latter behaves better when loading multiple AST files. llvm-svn: 137120
2011-08-09 23:13:55 +08:00
TypeID ASTWriter::GetOrCreateTypeID( QualType T) {
return MakeTypeID(*Context, 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
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 {
Migrate the serialization of ASTContext's AutoDeduceTy and AutoRRefDeductTy from the "special types" block to predefined types. The latter behaves better when loading multiple AST files. llvm-svn: 137120
2011-08-09 23:13:55 +08:00
return MakeTypeID(*Context, 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
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) {
[PCH] Make sure that all newly introduced visible decls in a DeclContext coming from an AST file are registered for serialization. A static data member instantiation of in a chained PCH could be missed when serializing decls; the result was that when emitting the visible decls map of its DeclContext, we would use a DeclID that was not actually emitted, leading to crashes or hangs. Fix this by making sure such decls are always registered for serialization. Also introduce extra sanity checks to make sure we don't register new declarations or types after we have serialized the types/decls block. rdar://11728990 llvm-svn: 159550
2012-07-03 03:19:01 +08:00
if (DoneWritingDeclsAndTypes) {
assert(0 && "New type seen after serializing all the types to emit!");
return TypeIdx();
}
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
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
void ASTWriter::AddDeclRef(const Decl *D, RecordDataImpl &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) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(WritingAST && "Cannot request a declaration ID before AST writing");
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
}
Don't seed the ASTWriter's declaration -> ID mapping with the IDs of each deserialized declaration, since that information is already available in each declaration. llvm-svn: 147619
2012-01-06 06:33:30 +08:00
// If D comes from an AST file, its declaration ID is already known and
// fixed.
if (D->isFromASTFile())
return D->getGlobalID();
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) {
[PCH] Make sure that all newly introduced visible decls in a DeclContext coming from an AST file are registered for serialization. A static data member instantiation of in a chained PCH could be missed when serializing decls; the result was that when emitting the visible decls map of its DeclContext, we would use a DeclID that was not actually emitted, leading to crashes or hangs. Fix this by making sure such decls are always registered for serialization. Also introduce extra sanity checks to make sure we don't register new declarations or types after we have serialized the types/decls block. rdar://11728990 llvm-svn: 159550
2012-07-03 03:19:01 +08:00
if (DoneWritingDeclsAndTypes) {
assert(0 && "New decl seen after serializing all the decls to emit!");
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
// 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));
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;
Don't seed the ASTWriter's declaration -> ID mapping with the IDs of each deserialized declaration, since that information is already available in each declaration. llvm-svn: 147619
2012-01-06 06:33:30 +08:00
// If D comes from an AST file, its declaration ID is already known and
// fixed.
if (D->isFromASTFile())
return D->getGlobalID();
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
assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
return DeclIDs[D];
}
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
static inline bool compLocDecl(std::pair<unsigned, serialization::DeclID> L,
std::pair<unsigned, serialization::DeclID> R) {
return L.first < R.first;
}
[PCH] In ASTWriter::associateDeclWithFile don't bother finding the file loc if we are not interested in the decl. llvm-svn: 143255
2011-10-29 07:57:43 +08:00
void ASTWriter::associateDeclWithFile(const Decl *D, DeclID ID) {
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
assert(ID);
[PCH] In ASTWriter::associateDeclWithFile don't bother finding the file loc if we are not interested in the decl. llvm-svn: 143255
2011-10-29 07:57:43 +08:00
assert(D);
SourceLocation Loc = D->getLocation();
if (Loc.isInvalid())
return;
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
// We only keep track of the file-level declarations of each file.
if (!D->getLexicalDeclContext()->isFileContext())
return;
Change the text of a FIXME. llvm-svn: 151387
2012-02-25 03:45:46 +08:00
// FIXME: ParmVarDecls that are part of a function type of a parameter of
// a function/objc method, should not have TU as lexical context.
[PCH] When keeping track of top-level decls for "targeted deserialization" make sure we don't mistake ParmVarDecls for top-level decls. Fixes rdar://10920009. llvm-svn: 151330
2012-02-24 09:12:38 +08:00
if (isa<ParmVarDecl>(D))
return;
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
SourceManager &SM = Context->getSourceManager();
[PCH] In ASTWriter::associateDeclWithFile don't bother finding the file loc if we are not interested in the decl. llvm-svn: 143255
2011-10-29 07:57:43 +08:00
SourceLocation FileLoc = SM.getFileLoc(Loc);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
assert(SM.isLocalSourceLocation(FileLoc));
[PCH] Sort the file decls by file offset not raw source location. Currently sorting by raw source location does work as intended but who knows what may change in the future.. llvm-svn: 143256
2011-10-29 07:57:47 +08:00
FileID FID;
unsigned Offset;
llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
if (FID.isInvalid())
return;
[PCH/Module] Change the map of file-level DeclIDs to use a FileID as key instead of a SLocEntry pointer. This allows the array of file sorted declarations in a PCH/module to be deterministic. llvm-svn: 165047
2012-10-03 05:09:17 +08:00
assert(SM.getSLocEntry(FID).isFile());
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
[PCH/Module] Change the map of file-level DeclIDs to use a FileID as key instead of a SLocEntry pointer. This allows the array of file sorted declarations in a PCH/module to be deterministic. llvm-svn: 165047
2012-10-03 05:09:17 +08:00
DeclIDInFileInfo *&Info = FileDeclIDs[FID];
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
if (!Info)
Info = new DeclIDInFileInfo();
[PCH] Sort the file decls by file offset not raw source location. Currently sorting by raw source location does work as intended but who knows what may change in the future.. llvm-svn: 143256
2011-10-29 07:57:47 +08:00
std::pair<unsigned, serialization::DeclID> LocDecl(Offset, ID);
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
LocDeclIDsTy &Decls = Info->DeclIDs;
[PCH] Sort the file decls by file offset not raw source location. Currently sorting by raw source location does work as intended but who knows what may change in the future.. llvm-svn: 143256
2011-10-29 07:57:47 +08:00
if (Decls.empty() || Decls.back().first <= Offset) {
[PCH] Keep track of file-level declarations that are contained by files. Introduce a FILE_SORTED_DECLS [de]serialization record that contains a file sorted array of file-level DeclIDs in a PCH/Module. The rationale is to allow "targeted" deserialization of decls inside a range of a source file. Cocoa PCH increased by 0.8% Difference of creation time for Cocoa PCH is below the noise level. llvm-svn: 143238
2011-10-29 06:54:21 +08:00
Decls.push_back(LocDecl);
return;
}
LocDeclIDsTy::iterator
I = std::upper_bound(Decls.begin(), Decls.end(), LocDecl, compLocDecl);
Decls.insert(I, LocDecl);
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddDeclarationName(DeclarationName Name, RecordDataImpl &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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
DeclarationName Name, RecordDataImpl &Record) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
AddDeclarationName(NameInfo.getName(), Record);
AddSourceLocation(NameInfo.getLoc(), Record);
AddDeclarationNameLoc(NameInfo.getInfo(), NameInfo.getName(), Record);
}
void ASTWriter::AddQualifierInfo(const QualifierInfo &Info,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
Use NestedNameSpecifierLoc within out-of-line variables, function, and tag definitions. Also, add support for template instantiation of NestedNameSpecifierLocs. llvm-svn: 126470
2011-02-25 10:25:35 +08:00
AddNestedNameSpecifierLoc(Info.QualifierLoc, Record);
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &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
// Nested name specifiers usually aren't too long. I think that 8 would
fix a bunch of comment typos found by codespell. Patch by Luis Felipe Strano Moraes! llvm-svn: 129559
2011-04-15 13:22:18 +08:00
// typically accommodate the vast majority.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NestedNameSpecifier *, 8> NestedNames;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
// 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;
Teach NestedNameSpecifier to keep track of namespace aliases the same way it keeps track of namespaces. Previously, we would map from the namespace alias to its underlying namespace when building a nested-name-specifier, losing source information in the process. llvm-svn: 126358
2011-02-24 10:36:08 +08:00
case NestedNameSpecifier::NamespaceAlias:
AddDeclRef(NNS->getAsNamespaceAlias(), Record);
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
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
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
void ASTWriter::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
RecordDataImpl &Record) {
// Nested name specifiers usually aren't too long. I think that 8 would
fix a bunch of comment typos found by codespell. Patch by Luis Felipe Strano Moraes! llvm-svn: 129559
2011-04-15 13:22:18 +08:00
// typically accommodate the vast majority.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
// Push each of the nested-name-specifiers'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.getNestedNameSpecifier()->getKind();
Record.push_back(Kind);
switch (Kind) {
case NestedNameSpecifier::Identifier:
AddIdentifierRef(NNS.getNestedNameSpecifier()->getAsIdentifier(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
break;
case NestedNameSpecifier::Namespace:
AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespace(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
break;
case NestedNameSpecifier::NamespaceAlias:
AddDeclRef(NNS.getNestedNameSpecifier()->getAsNamespaceAlias(), Record);
AddSourceRange(NNS.getLocalSourceRange(), Record);
break;
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
Record.push_back(Kind == NestedNameSpecifier::TypeSpecWithTemplate);
AddTypeLoc(NNS.getTypeLoc(), Record);
AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
break;
case NestedNameSpecifier::Global:
AddSourceLocation(NNS.getLocalSourceRange().getEnd(), Record);
break;
}
}
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddTemplateName(TemplateName Name, RecordDataImpl &Record) {
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
TemplateName::NameKind Kind = Name.getKind();
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
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;
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
case TemplateName::QualifiedTemplate: {
QualifiedTemplateName *QualT = Name.getAsQualifiedTemplateName();
AddNestedNameSpecifier(QualT->getQualifier(), Record);
Record.push_back(QualT->hasTemplateKeyword());
AddDeclRef(QualT->getTemplateDecl(), Record);
break;
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
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;
}
Preserve that a TemplateName was arrived at by substituting for a template template parameter. Uses to follow. I've also made the uniquing of SubstTemplateTemplateParmPacks use a ContextualFoldingSet as a minor space efficiency. llvm-svn: 134137
2011-06-30 16:33:18 +08:00
case TemplateName::SubstTemplateTemplateParm: {
SubstTemplateTemplateParmStorage *subst
= Name.getAsSubstTemplateTemplateParm();
AddDeclRef(subst->getParameter(), Record);
AddTemplateName(subst->getReplacement(), Record);
break;
}
Introduce a new kind of TemplateName that captures a substituted template template parameter pack that cannot be fully expanded because its enclosing pack expansion could not be expanded. This form of TemplateName plays the same role as SubstTemplateTypeParmPackType and SubstNonTypeTemplateParmPackExpr do for template type parameter packs and non-type template parameter packs, respectively. We should now handle these multi-level pack expansion substitutions anywhere. The largest remaining gap in our variadic-templates support is that we cannot cope with non-type template parameter packs whose type is a pack expansion. llvm-svn: 123521
2011-01-15 14:45:20 +08:00
case TemplateName::SubstTemplateTemplateParmPack: {
SubstTemplateTemplateParmPackStorage *SubstPack
= Name.getAsSubstTemplateTemplateParmPack();
AddDeclRef(SubstPack->getParameterPack(), Record);
AddTemplateArgument(SubstPack->getArgumentPack(), Record);
break;
}
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
}
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
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);
Fix the AST representation for non-type template arguments to encode enough information so we can mangle them correctly in cases involving dependent parameter types. (This specifically impacts cases involving null pointers and cases involving parameters of reference type.) Fix the mangler to use this information instead of trying to scavenge it out of the parameter declaration. <rdar://problem/12296776>. llvm-svn: 164656
2012-09-26 10:36:12 +08:00
Record.push_back(Arg.isDeclForReferenceParam());
break;
case TemplateArgument::NullPtr:
AddTypeRef(Arg.getNullPtrType(), Record);
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
break;
case TemplateArgument::Integral:
Plug a long standing memory leak in TemplateArgument. The integral APSInt value is now stored in a decomposed form and the backing store for large values is allocated via the ASTContext. This way its not leaked as TemplateArguments are never destructed when they are allocated in the ASTContext. Since the integral data is immutable it is now shared between instances, making copying TemplateArguments a trivial operation. Currently getting the integral data out of a TemplateArgument requires creating a new APSInt object. This is cheap when the value is small but can be expensive if it's not. If this turns out to be an issue a more efficient accessor could be added. llvm-svn: 158150
2012-06-07 23:09:51 +08:00
AddAPSInt(Arg.getAsIntegral(), Record);
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
AddTypeRef(Arg.getIntegralType(), Record);
break;
case TemplateArgument::Template:
Teach template template argument pack expansions to keep track of the number of expansions, when we know it, and propagate that information through Sema. llvm-svn: 123493
2011-01-15 07:41:42 +08:00
AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
break;
Replace the representation of template template argument pack expansions with something that is easier to use correctly: a new template argment kind, rather than a bit on an existing kind. Update all of the switch statements that deal with template arguments, fixing a few latent bugs in the process. I"m happy with this representation, now. And, oh look! Template instantiation and deduction work for template template argument pack expansions. llvm-svn: 122896
2011-01-06 02:58:31 +08:00
case TemplateArgument::TemplateExpansion:
AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record);
Teach template template argument pack expansions to keep track of the number of expansions, when we know it, and propagate that information through Sema. llvm-svn: 123493
2011-01-15 07:41:42 +08:00
if (llvm::Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
Record.push_back(*NumExpansions + 1);
else
Record.push_back(0);
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
assert(TemplateArgs && "No TemplateArgs!");
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
Record.push_back(TemplateArgs->size());
for (int i=0, e = TemplateArgs->size(); i != e; ++i)
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
AddTemplateArgument(TemplateArgs->get(i), Record);
}
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
void
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordDataImpl &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,
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
RecordDataImpl &Record) {
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
Record.push_back(Base.isVirtual());
Record.push_back(Base.isBaseOfClass());
Record.push_back(Base.getAccessSpecifierAsWritten());
Basic implementation of inherited constructors. Only generates declarations, and probably only works for very basic use cases. llvm-svn: 124970
2011-02-06 03:23:19 +08:00
Record.push_back(Base.getInheritConstructors());
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);
Implement pack expansions whose pattern is a base-specifier. llvm-svn: 122782
2011-01-04 06:36:02 +08:00
AddSourceLocation(Base.isPackExpansion()? Base.getEllipsisLoc()
: SourceLocation(),
Record);
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
}
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
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
void ASTWriter::FlushCXXBaseSpecifiers() {
RecordData Record;
for (unsigned I = 0, N = CXXBaseSpecifiersToWrite.size(); I != N; ++I) {
Record.clear();
// Record the offset of this base-specifier set.
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
unsigned Index = CXXBaseSpecifiersToWrite[I].ID - 1;
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Index == CXXBaseSpecifiersOffsets.size())
CXXBaseSpecifiersOffsets.push_back(Stream.GetCurrentBitNo());
else {
if (Index > CXXBaseSpecifiersOffsets.size())
CXXBaseSpecifiersOffsets.resize(Index + 1);
CXXBaseSpecifiersOffsets[Index] = Stream.GetCurrentBitNo();
}
const CXXBaseSpecifier *B = CXXBaseSpecifiersToWrite[I].Bases,
*BEnd = CXXBaseSpecifiersToWrite[I].BasesEnd;
Record.push_back(BEnd - B);
for (; B != BEnd; ++B)
AddCXXBaseSpecifier(*B, Record);
Stream.EmitRecord(serialization::DECL_CXX_BASE_SPECIFIERS, Record);
Flush statements after writing each DECL_CXX_BASE_SPECIFIERS node llvm-svn: 117770
2010-10-30 12:28:16 +08:00
// Flush any expressions that were written as part of the base specifiers.
FlushStmts();
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
}
CXXBaseSpecifiersToWrite.clear();
}
Renamed CXXBaseOrMemberInitializer to CXXCtorInitializer. This is both shorter, more accurate, and makes it make sense for it to hold a delegating constructor call. llvm-svn: 123084
2011-01-09 04:30:50 +08:00
void ASTWriter::AddCXXCtorInitializers(
const CXXCtorInitializer * const *CtorInitializers,
unsigned NumCtorInitializers,
RecordDataImpl &Record) {
Record.push_back(NumCtorInitializers);
for (unsigned i=0; i != NumCtorInitializers; ++i) {
const CXXCtorInitializer *Init = CtorInitializers[i];
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
if (Init->isBaseInitializer()) {
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
Record.push_back(CTOR_INITIALIZER_BASE);
Rework the AST for the initializer of a delegating constructor, so that it retains source location information for the type. Aside from general goodness (being able to walk the types described in that information), we now have a proper representation for dependent delegating constructors. Fixes PR10457 (for real). llvm-svn: 143410
2011-11-01 09:16:03 +08:00
AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
Record.push_back(Init->isBaseVirtual());
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
} else if (Init->isDelegatingInitializer()) {
Record.push_back(CTOR_INITIALIZER_DELEGATING);
Rework the AST for the initializer of a delegating constructor, so that it retains source location information for the type. Aside from general goodness (being able to walk the types described in that information), we now have a proper representation for dependent delegating constructors. Fixes PR10457 (for real). llvm-svn: 143410
2011-11-01 09:16:03 +08:00
AddTypeSourceInfo(Init->getTypeSourceInfo(), Record);
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
} else if (Init->isMemberInitializer()){
Record.push_back(CTOR_INITIALIZER_MEMBER);
AddDeclRef(Init->getMember(), Record);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
} else {
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
Record.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
AddDeclRef(Init->getIndirectMember(), Record);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
}
More anonymous struct/union redesign. This one deals with anonymous field used in a constructor initializer list: struct X { X() : au_i1(123) {} union { int au_i1; float au_f1; }; }; clang will now deal with au_i1 explicitly as an IndirectFieldDecl. llvm-svn: 120900
2010-12-04 17:14:42 +08:00
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
AddSourceLocation(Init->getMemberLocation(), Record);
AddStmt(Init->getInit());
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);
}
}
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ASTWriter::AddCXXDefinitionData(const CXXRecordDecl *D, RecordDataImpl &Record) {
assert(D->DefinitionData);
struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData;
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Record.push_back(Data.IsLambda);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.UserDeclaredConstructor);
Record.push_back(Data.UserDeclaredCopyConstructor);
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Record.push_back(Data.UserDeclaredMoveConstructor);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.UserDeclaredCopyAssignment);
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Record.push_back(Data.UserDeclaredMoveAssignment);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.UserDeclaredDestructor);
Record.push_back(Data.Aggregate);
Record.push_back(Data.PlainOldData);
Record.push_back(Data.Empty);
Record.push_back(Data.Polymorphic);
Record.push_back(Data.Abstract);
Rename the last '[hH]asStandardLayout' entites to '[iI]sStandardLayout' based on Doug's preferences when we discussed this in IRC. This brings the wording more in line with the standard. llvm-svn: 130603
2011-04-30 18:07:30 +08:00
Record.push_back(Data.IsStandardLayout);
Completely re-implement the core logic behind the __is_standard_layout type trait. The previous implementation suffered from several problems: 1) It implemented all of the logic in RecordType by walking over every base and field in a CXXRecordDecl and validating the constraints of the standard. This made for very straightforward code, but is extremely inefficient. It also is conceptually wrong, the logic tied to the C++ definition of standard-layout classes should be in CXXRecordDecl, not RecordType. 2) To address the performance problems with #1, a cache bit was added to CXXRecordDecl, and at the completion of every C++ class, the RecordType was queried to determine if it was a standard layout class, and that state was cached. Two things went very very wrong with this. First, the caching version of the query *was never called*. Even within the recursive steps of the walk over all fields and bases the caching variant was not called, making each query a full *recursive* walk. Second, despite the cache not being used, it was computed for every class declared, even when the trait was never used in the program. This probably significantly regressed compile time performance for edge-case files. 3) An ASTContext was required merely to query the type trait because querying it performed the actual computations. 4) The caching bit wasn't managed correctly (uninitialized). The new implementation follows the system for all the other traits on C++ classes by encoding all the state needed in the definition data and building up the trait incrementally as each base and member are added to the definition of the class. The idiosyncracies of the specification of standard-layout classes requires more state than I would like; currently 5 bits. I could eliminate one of the bits easily at the expense of both clarity and resilience of the code. I might be able to eliminate one of the other bits by computing its state in terms of other state bits in the definition. I've already done that in one place where there was a fairly simple way to achieve it. It's possible some of the bits could be moved out of the definition data and into some other structure which isn't serialized if the serialized bloat is a problem. That would preclude serialization of a partial class declaration, but that's likely already precluded. Comments on any of these issues welcome. llvm-svn: 130601
2011-04-30 17:17:45 +08:00
Record.push_back(Data.HasNoNonEmptyBases);
Record.push_back(Data.HasPrivateFields);
Record.push_back(Data.HasProtectedFields);
Record.push_back(Data.HasPublicFields);
When determining whether we can make a declaration into a global constant, also consider whether it's a class type that has any mutable fields. If so, it can't be a global constant. llvm-svn: 131276
2011-05-13 09:05:07 +08:00
Record.push_back(Data.HasMutableFields);
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Record.push_back(Data.HasOnlyCMembers);
A union can have a constexpr defaulted default constructor, if it has an in-class initializer for one of its fields. Value-initialization of such a type should use the in-class initializer! The former was just a bug, the latter is a (reported) standard defect. llvm-svn: 156274
2012-05-07 09:07:30 +08:00
Record.push_back(Data.HasInClassInitializer);
Rename "hasTrivialConstructor" to "hasTrivialDefaultConstructor" and modify the semantics slightly to accomodate default constructors (I hope). llvm-svn: 131087
2011-05-10 02:22:59 +08:00
Record.push_back(Data.HasTrivialDefaultConstructor);
Renamings to consistently use 'Constexpr' not 'ConstExpr' when referring to the C++0x 'constexpr' keyword. llvm-svn: 137230
2011-08-11 02:11:37 +08:00
Record.push_back(Data.HasConstexprNonCopyMoveConstructor);
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Record.push_back(Data.DefaultedDefaultConstructorIsConstexpr);
Record.push_back(Data.HasConstexprDefaultConstructor);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.HasTrivialCopyConstructor);
Begin tracking trivialness of move constructors and move assignment operators in C++ record declarations. This patch starts off by updating a bunch of the standard citations to refer to the draft 0x standard so that the semantics intended for move varianst is clear. Where necessary these are duplicated so they'll be available in doxygen. It adds bit fields to keep track of the state for the move constructs, and updates all the code necessary to track this state (I think) as members are declared for a class. It also wires the state into the various trait-like accessors in the AST's API, and tests that the type trait expressions now behave correctly in the presence of move constructors and move assignment operators. This isn't complete yet due to these glaring FIXMEs: 1) No synthesis of implicit move constructors or assignment operators. 2) I don't think we correctly enforce the new logic for both copy and move trivial checks: that the *selected* copy/move constructor/operator is trivial. Currently this requires *all* of them to be trivial. 3) Some of the trait logic needs to be folded into the fine-grained trivial bits to more closely match the wording of the standard. For example, many of the places we currently set a bit to track POD-ness could be removed by querying other more fine grained traits on demand. llvm-svn: 130076
2011-04-24 07:10:33 +08:00
Record.push_back(Data.HasTrivialMoveConstructor);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.HasTrivialCopyAssignment);
Begin tracking trivialness of move constructors and move assignment operators in C++ record declarations. This patch starts off by updating a bunch of the standard citations to refer to the draft 0x standard so that the semantics intended for move varianst is clear. Where necessary these are duplicated so they'll be available in doxygen. It adds bit fields to keep track of the state for the move constructs, and updates all the code necessary to track this state (I think) as members are declared for a class. It also wires the state into the various trait-like accessors in the AST's API, and tests that the type trait expressions now behave correctly in the presence of move constructors and move assignment operators. This isn't complete yet due to these glaring FIXMEs: 1) No synthesis of implicit move constructors or assignment operators. 2) I don't think we correctly enforce the new logic for both copy and move trivial checks: that the *selected* copy/move constructor/operator is trivial. Currently this requires *all* of them to be trivial. 3) Some of the trait logic needs to be folded into the fine-grained trivial bits to more closely match the wording of the standard. For example, many of the places we currently set a bit to track POD-ness could be removed by querying other more fine grained traits on demand. llvm-svn: 130076
2011-04-24 07:10:33 +08:00
Record.push_back(Data.HasTrivialMoveAssignment);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.HasTrivialDestructor);
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Record.push_back(Data.HasIrrelevantDestructor);
Implement most of the remaining logic in __is_literal type trait. This should now support all of the C++98 types, and all of the C++0x types Clang supports. llvm-svn: 130079
2011-04-24 10:49:34 +08:00
Record.push_back(Data.HasNonLiteralTypeFieldsOrBases);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.ComputedVisibleConversions);
Implement implicit deletion of default constructors. Yes, I'm aware that the diagnostics are awful. Tests to follow. llvm-svn: 131203
2011-05-12 06:34:38 +08:00
Record.push_back(Data.UserProvidedDefaultConstructor);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.DeclaredDefaultConstructor);
Record.push_back(Data.DeclaredCopyConstructor);
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Record.push_back(Data.DeclaredMoveConstructor);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.DeclaredCopyAssignment);
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Record.push_back(Data.DeclaredMoveAssignment);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.DeclaredDestructor);
Serialize the new bits in CXXRecordDecl::DefinitionData. llvm-svn: 138855
2011-08-31 21:59:56 +08:00
Record.push_back(Data.FailedImplicitMoveConstructor);
Record.push_back(Data.FailedImplicitMoveAssignment);
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
// IsLambda bit is already saved.
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
Record.push_back(Data.NumBases);
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Data.NumBases > 0)
AddCXXBaseSpecifiersRef(Data.getBases(), Data.getBases() + Data.NumBases,
Record);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
// FIXME: Make VBases lazily computed when needed to avoid storing them.
Record.push_back(Data.NumVBases);
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Data.NumVBases > 0)
AddCXXBaseSpecifiersRef(Data.getVBases(), Data.getVBases() + Data.NumVBases,
Record);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
AddUnresolvedSet(Data.Conversions, Record);
AddUnresolvedSet(Data.VisibleConversions, Record);
// Data.Definition is the owning decl, no need to write it.
AddDeclRef(Data.FirstFriend, Record);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
// Add lambda-specific data.
if (Data.IsLambda) {
CXXRecordDecl::LambdaDefinitionData &Lambda = D->getLambdaData();
Improve our handling of lambda expressions that occur within default arguments. There are two aspects to this: - Make sure that when marking the declarations referenced in a default argument, we don't try to mark local variables, both because it's a waste of time and because the semantics are wrong: we're not in a place where we could capture these variables again even if it did make sense. - When a lambda expression occurs in a default argument of a function template, make sure that the corresponding closure type is considered dependent, so that it will get properly instantiated. The second bit is a bit of a hack; to fix it properly, we may have to rearchitect our handling of default arguments, parsing them only after creating the function definition. However, I'd like to separate that work from the lambdas work. llvm-svn: 151076
2012-02-22 03:11:17 +08:00
Record.push_back(Lambda.Dependent);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Record.push_back(Lambda.NumCaptures);
Record.push_back(Lambda.NumExplicitCaptures);
Basic support for name mangling of C++11 lambda expressions. Because name mangling in the Itanium C++ ABI for lambda expressions is so dependent on context, we encode the number used to encode each lambda as part of the lambda closure type, and maintain this value within Sema. Note that there are a several pieces still missing: - We still get the linkage of lambda expressions wrong - We aren't properly numbering or mangling lambda expressions that occur in default function arguments or in data member initializers. - We aren't (de-)serializing the lambda numbering tables llvm-svn: 150982
2012-02-21 03:44:39 +08:00
Record.push_back(Lambda.ManglingNumber);
Implement name mangling for lambda expressions that occur within the default arguments of function parameters. This simple-sounding task is complicated greatly by two issues: (1) Default arguments aren't actually a real context, so we need to maintain extra state within lambda expressions to track when a lambda was actually in a default argument. (2) At the time that we parse a default argument, the FunctionDecl doesn't exist yet, so lambda closure types end up in the enclosing context. It's not clear that we ever want to change that, so instead we introduce the notion of the "effective" context of a declaration for the purposes of name mangling. llvm-svn: 151011
2012-02-21 08:37:24 +08:00
AddDeclRef(Lambda.ContextDecl, Record);
Add the TypeSourceInfo for the lambda call operator to the lambda's definition info; it needs to be there because the mangler needs to access it before we're finished defining the lambda class. PR12808. llvm-svn: 164186
2012-09-19 09:18:11 +08:00
AddTypeSourceInfo(Lambda.MethodTyInfo, Record);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
LambdaExpr::Capture &Capture = Lambda.Captures[I];
AddSourceLocation(Capture.getLocation(), Record);
Record.push_back(Capture.isImplicit());
Record.push_back(Capture.getCaptureKind()); // FIXME: stable!
VarDecl *Var = Capture.capturesVariable()? Capture.getCapturedVar() : 0;
AddDeclRef(Var, Record);
AddSourceLocation(Capture.isPackExpansion()? Capture.getEllipsisLoc()
: SourceLocation(),
Record);
}
}
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
void ASTWriter::ReaderInitialized(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");
Keep track of which modules have been loaded directly (e.g., via -import-module) vs. loaded because some other module depends on them. As part of doing this, pass down the module that caused a module to be loaded directly, rather than assuming that we're loading a chain. Finally, write out all of the directly-loaded modules when serializing an AST file (using the new IMPORTS record), so that an AST file can depend on more than one other AST file, all of which will be loaded when that AST file is loaded. This allows us to form and load a tree of modules, but we can't yet load a DAG of modules. llvm-svn: 137923
2011-08-18 12:12:04 +08:00
assert((!Chain || Chain == Reader) && "Cannot replace chain");
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(FirstDeclID == NextDeclID &&
FirstTypeID == NextTypeID &&
FirstIdentID == NextIdentID &&
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
FirstMacroID == NextMacroID &&
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
FirstSubmoduleID == NextSubmoduleID &&
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
FirstSelectorID == NextSelectorID &&
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.");
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
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
Chain = Reader;
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
Keep track of which modules have been loaded directly (e.g., via -import-module) vs. loaded because some other module depends on them. As part of doing this, pass down the module that caused a module to be loaded directly, rather than assuming that we're loading a chain. Finally, write out all of the directly-loaded modules when serializing an AST file (using the new IMPORTS record), so that an AST file can depend on more than one other AST file, all of which will be loaded when that AST file is loaded. This allows us to form and load a tree of modules, but we can't yet load a DAG of modules. llvm-svn: 137923
2011-08-18 12:12:04 +08:00
FirstDeclID = NUM_PREDEF_DECL_IDS + Chain->getTotalNumDecls();
FirstTypeID = NUM_PREDEF_TYPE_IDS + Chain->getTotalNumTypes();
FirstIdentID = NUM_PREDEF_IDENT_IDS + Chain->getTotalNumIdentifiers();
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
FirstMacroID = NUM_PREDEF_MACRO_IDS + Chain->getTotalNumMacros();
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
FirstSubmoduleID = NUM_PREDEF_SUBMODULE_IDS + Chain->getTotalNumSubmodules();
Keep track of which modules have been loaded directly (e.g., via -import-module) vs. loaded because some other module depends on them. As part of doing this, pass down the module that caused a module to be loaded directly, rather than assuming that we're loading a chain. Finally, write out all of the directly-loaded modules when serializing an AST file (using the new IMPORTS record), so that an AST file can depend on more than one other AST file, all of which will be loaded when that AST file is loaded. This allows us to form and load a tree of modules, but we can't yet load a DAG of modules. llvm-svn: 137923
2011-08-18 12:12:04 +08:00
FirstSelectorID = NUM_PREDEF_SELECTOR_IDS + Chain->getTotalNumSelectors();
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
NextDeclID = FirstDeclID;
NextTypeID = FirstTypeID;
NextIdentID = FirstIdentID;
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
NextMacroID = FirstMacroID;
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
NextSelectorID = FirstSelectorID;
Switch the ID numbers used for submodule IDs in the AST reader over to a standard global/local scheme, so that submodule definitions will eventually be able to refer to submodules in other top-level modules. We'll need this functionality soonish. llvm-svn: 145549
2011-12-01 08:59:36 +08:00
NextSubmoduleID = FirstSubmoduleID;
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
}
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;
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
void ASTWriter::MacroRead(serialization::MacroID ID, MacroInfo *MI) {
MacroIDs[MI] = 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,
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
// later, deserialize the type from another AST. In this case, we want to
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
// 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::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
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
void ASTWriter::MacroDefinitionRead(serialization::PreprocessedEntityID 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
MacroDefinition *MD) {
[PCH] Overhaul how preprocessed entities are [de]serialized. -Use an array of offsets for all preprocessed entities -Get rid of the separate array of offsets for just macro definitions; for references to macro definitions use an index inside the preprocessed entities array. -Deserialize each preprocessed entity lazily, at first request; not in bulk. Paves the way for binary searching of preprocessed entities that will offer efficiency and will simplify things on the libclang side a lot. llvm-svn: 139809
2011-09-16 02:02:56 +08:00
assert(MacroDefinitions.find(MD) == MacroDefinitions.end());
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
MacroDefinitions[MD] = ID;
}
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
Notify the AST writer (via ASTDeserializationListener) when a (sub)module is read from an AST file. This makes sure that the AST writer knows how to map all modules to their global IDs. llvm-svn: 145685
2011-12-03 01:30:13 +08:00
void ASTWriter::ModuleRead(serialization::SubmoduleID ID, Module *Mod) {
assert(SubmoduleIDs.find(Mod) == SubmoduleIDs.end());
SubmoduleIDs[Mod] = ID;
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
void ASTWriter::UndefinedMacro(MacroInfo *MI) {
MacroUpdates[MI].UndefLoc = MI->getUndefLoc();
}
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
void ASTWriter::CompletedTagDefinition(const TagDecl *D) {
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
assert(D->isCompleteDefinition());
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
// We are interested when a PCH decl is modified.
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (RD->isFromASTFile()) {
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
// A forward reference was mutated into a definition. Rewrite it.
// FIXME: This happens during template instantiation, should we
// have created a new definition decl instead ?
Fix the re-serializing decls in a chained PCH mechanism. llvm-svn: 117534
2010-10-28 15:38:45 +08:00
RewriteDecl(RD);
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
}
}
}
Rework the (de-)serialization of macros, as stored in MacroInfo*. Instead of simply dumping an offset into the current file, give each macro definition a proper ID with all of the standard modules-remapping facilities. Additionally, when a macro is modified in a subsequent AST file (e.g., #undef'ing a macro loaded from another module or from a precompiled header), provide a macro update record rather than rewriting the entire macro definition. This gives us greater consistency with the way we handle declarations, and ties together macro definitions much more cleanly. Note that we're still not actually deserializing macro history (we never were), but it's far easy to do properly now. llvm-svn: 165560
2012-10-10 07:05:51 +08:00
Use the ASTMutationListener to track when a named decl gets added to a DeclContext, meaning we need to rewrite its name lookup table in a chained PCH. llvm-svn: 117536
2010-10-28 15:38:51 +08:00
void ASTWriter::AddedVisibleDecl(const DeclContext *DC, const Decl *D) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Use the ASTMutationListener to track when a named decl gets added to a DeclContext, meaning we need to rewrite its name lookup table in a chained PCH. llvm-svn: 117536
2010-10-28 15:38:51 +08:00
// TU and namespaces are handled elsewhere.
if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC))
return;
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!(!D->isFromASTFile() && cast<Decl>(DC)->isFromASTFile()))
Use the ASTMutationListener to track when a named decl gets added to a DeclContext, meaning we need to rewrite its name lookup table in a chained PCH. llvm-svn: 117536
2010-10-28 15:38:51 +08:00
return; // Not a source decl added to a DeclContext from PCH.
AddUpdatedDeclContext(DC);
[PCH] Make sure that all newly introduced visible decls in a DeclContext coming from an AST file are registered for serialization. A static data member instantiation of in a chained PCH could be missed when serializing decls; the result was that when emitting the visible decls map of its DeclContext, we would use a DeclID that was not actually emitted, leading to crashes or hangs. Fix this by making sure such decls are always registered for serialization. Also introduce extra sanity checks to make sure we don't register new declarations or types after we have serialized the types/decls block. rdar://11728990 llvm-svn: 159550
2012-07-03 03:19:01 +08:00
UpdatingVisibleDecls.push_back(D);
Use the ASTMutationListener to track when a named decl gets added to a DeclContext, meaning we need to rewrite its name lookup table in a chained PCH. llvm-svn: 117536
2010-10-28 15:38:51 +08:00
}
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
void ASTWriter::AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
assert(D->isImplicit());
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!(!D->isFromASTFile() && RD->isFromASTFile()))
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
return; // Not a source member added to a class from PCH.
if (!isa<CXXMethodDecl>(D))
return; // We are interested in lazily declared implicit methods.
// A decl coming from PCH was modified.
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
assert(RD->isCompleteDefinition());
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
UpdateRecord &Record = DeclUpdates[RD];
Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER);
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
Record.push_back(reinterpret_cast<uint64_t>(D));
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
}
Use the ASTMutationListener to track added template specializations in a chained PCH. llvm-svn: 117533
2010-10-28 15:38:42 +08:00
void ASTWriter::AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
const ClassTemplateSpecializationDecl *D) {
Properly add chained template specializations. llvm-svn: 117535
2010-10-28 15:38:47 +08:00
// The specializations set is kept in the canonical template.
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Properly add chained template specializations. llvm-svn: 117535
2010-10-28 15:38:47 +08:00
TD = TD->getCanonicalDecl();
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!(!D->isFromASTFile() && TD->isFromASTFile()))
Use the ASTMutationListener to track added template specializations in a chained PCH. llvm-svn: 117533
2010-10-28 15:38:42 +08:00
return; // Not a source specialization added to a template from PCH.
UpdateRecord &Record = DeclUpdates[TD];
Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
Record.push_back(reinterpret_cast<uint64_t>(D));
Use the ASTMutationListener to track added template specializations in a chained PCH. llvm-svn: 117533
2010-10-28 15:38:42 +08:00
}
When using a precompiled preamble with detailed preprocessing records, trap the serialized preprocessing records (macro definitions, macro instantiations, macro definitions) from the generation of the precompiled preamble, then replay those when walking the list of preprocessed entities. This eliminates a bug where clang_getCursor() wasn't able to find preprocessed-entity cursors in the preamble. llvm-svn: 120396
2010-11-30 14:16:57 +08:00
Chained PCH: Remember when additional specializations are added to a function template from a previous PCH. Fixes the only crasher when using massive chains on Clang's Sema component. We still have some incomplete codegen there. llvm-svn: 129516
2011-04-14 22:07:59 +08:00
void ASTWriter::AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
const FunctionDecl *D) {
// The specializations set is kept in the canonical template.
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Chained PCH: Remember when additional specializations are added to a function template from a previous PCH. Fixes the only crasher when using massive chains on Clang's Sema component. We still have some incomplete codegen there. llvm-svn: 129516
2011-04-14 22:07:59 +08:00
TD = TD->getCanonicalDecl();
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!(!D->isFromASTFile() && TD->isFromASTFile()))
Chained PCH: Remember when additional specializations are added to a function template from a previous PCH. Fixes the only crasher when using massive chains on Clang's Sema component. We still have some incomplete codegen there. llvm-svn: 129516
2011-04-14 22:07:59 +08:00
return; // Not a source specialization added to a template from PCH.
UpdateRecord &Record = DeclUpdates[TD];
Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
Record.push_back(reinterpret_cast<uint64_t>(D));
Chained PCH: Remember when additional specializations are added to a function template from a previous PCH. Fixes the only crasher when using massive chains on Clang's Sema component. We still have some incomplete codegen there. llvm-svn: 129516
2011-04-14 22:07:59 +08:00
}
Synthesizing the definition of an implicit member is an AST modification, so notify any mutation listeners of it. This fixes a crasher in chained PCH, where an implicit destructor in a PCH gets a definition in a chained PCH, which is then lost. However, any further use of the destructor would cause its definition to be regenerated in the final file, hiding the bug. llvm-svn: 130103
2011-04-25 00:28:06 +08:00
void ASTWriter::CompletedImplicitDefinition(const FunctionDecl *D) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!D->isFromASTFile())
Synthesizing the definition of an implicit member is an AST modification, so notify any mutation listeners of it. This fixes a crasher in chained PCH, where an implicit destructor in a PCH gets a definition in a chained PCH, which is then lost. However, any further use of the destructor would cause its definition to be regenerated in the final file, hiding the bug. llvm-svn: 130103
2011-04-25 00:28:06 +08:00
return; // Declaration not imported from PCH.
// Implicit decl from a PCH was defined.
// FIXME: Should implicit definition be a separate FunctionDecl?
RewriteDecl(D);
}
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
void ASTWriter::StaticDataMemberInstantiated(const VarDecl *D) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!D->isFromASTFile())
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
return;
// Since the actual instantiation is delayed, this really means that we need
// to update the instantiation location.
UpdateRecord &Record = DeclUpdates[D];
Record.push_back(UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER);
AddSourceLocation(
D->getMemberSpecializationInfo()->getPointOfInstantiation(), Record);
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
void ASTWriter::AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
const ObjCInterfaceDecl *IFD) {
With modules, we can end up loading a new module after we've seen an arbitrary amount of code. This forces us to stage the AST writer more strictly, ensuring that we don't assign a declaration ID to a declaration until after we're certain that no more modules will get loaded. llvm-svn: 139974
2011-09-17 08:05:03 +08:00
assert(!WritingAST && "Already writing the AST!");
Introduce a new predicate Decl::isFromASTFile() to determine whether a declaration was deserialized from an AST file. Use this instead of Decl::getPCHLevel() wherever possible. This is a simple step toward killing off Decl::getPCHLevel(). llvm-svn: 139427
2011-09-10 07:01:35 +08:00
if (!IFD->isFromASTFile())
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
return; // Declaration not imported from PCH.
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
assert(IFD->getDefinition() && "Category on a class without a definition?");
ObjCClassesWithCategories.insert(
const_cast<ObjCInterfaceDecl *>(IFD->getDefinition()));
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
[PCH] When completing an objc forward reference, do not serialize the chain of its categories because it is going to be rewritten (and the chain will be serialized again), otherwise we may form a cycle in its categories list when deserializing. Also introduce ASTMutationListener::CompletedObjCForwardRef to notify that a forward reference was completed; using Decl's isChangedSinceDeserialization/setChangedSinceDeserialization is bug inducing and kinda gross, we should phase it out. Fixes infinite loop in rdar://10418538. llvm-svn: 144465
2011-11-13 05:07:46 +08:00
Add a method in ASTMutationListener for the last use of Decl's [is/set]ChangedSinceDeserialization and remove them. llvm-svn: 144466
2011-11-13 05:07:52 +08:00
[PCH] Do not crash if a class extension in a chained PCH introduces/redeclares a property. llvm-svn: 144520
2011-11-14 12:52:29 +08:00
void ASTWriter::AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop,
const ObjCPropertyDecl *OrigProp,
const ObjCCategoryDecl *ClassExt) {
const ObjCInterfaceDecl *D = ClassExt->getClassInterface();
if (!D)
return;
assert(!WritingAST && "Already writing the AST!");
if (!D->isFromASTFile())
return; // Declaration not imported from PCH.
RewriteDecl(D);
}