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

3993 lines
146 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"
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
#include "clang/Serialization/ASTSerializationListener.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"
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
#include "clang/Lex/MacroInfo.h"
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
#include "clang/Lex/PreprocessingRecord.h"
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
#include "clang/Lex/Preprocessor.h"
Add PCH support for #import. llvm-svn: 69987
2009-04-25 04:03:17 +08:00
#include "clang/Lex/HeaderSearch.h"
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
#include "clang/Basic/FileManager.h"
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"
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) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
assert(false && "Built-in types are never serialized");
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitComplexType(const ComplexType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getElementType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_COMPLEX;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitPointerType(const PointerType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitBlockPointerType(const BlockPointerType *T) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_BLOCK_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitLValueReferenceType(const LValueReferenceType *T) {
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());
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());
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_FUNCTION_PROTO;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_UNRESOLVED_USING;
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTypedefType(const TypedefType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
- Allow a typedef type to be read from PCH even if its decl is currently initializing. - Fix creation of TemplateSpecializationType. llvm-svn: 107471
2010-07-02 19:55:11 +08:00
assert(!T->isCanonicalUnqualified() && "Invalid typedef ?");
Writer.AddTypeRef(T->getCanonicalTypeInternal(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TYPEDEF;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Writer.AddStmt(T->getUnderlyingExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TYPEOF_EXPR;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitTypeOfType(const TypeOfType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddTypeRef(T->getUnderlyingType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_TYPEOF;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
Add a DecltypeType type. llvm-svn: 74099
2009-06-25 03:06:50 +08:00
Writer.AddStmt(T->getUnderlyingExpr());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_DECLTYPE;
Add a DecltypeType type. llvm-svn: 74099
2009-06-25 03:06:50 +08:00
}
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());
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(!T->isBeingDefined() &&
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
"Cannot serialize in the middle of a type definition");
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitRecordType(const RecordType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitTagType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_RECORD;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitEnumType(const EnumType *T) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
VisitTagType(T);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_ENUM;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
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)
assert(false && "Cannot serialize dependent sized extended vector types");
}
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
Record.push_back(T->getDepth());
Record.push_back(T->getIndex());
Record.push_back(T->isParameterPack());
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) {
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Make the InjectedClassNameType the canonical type of the current instantiation of a class template or class template partial specialization. That is to say, in template <class T> class A { ... }; or template <class T> class B<const T*> { ... }; make 'A<T>' and 'B<const T*>' sugar for the corresponding InjectedClassNameType when written inside the appropriate context. This allows us to track the current instantiation appropriately even inside AST routines. It also allows us to compute a DeclContext for a type much more efficiently, at some extra cost every time we write a template specialization (which can be optimized, but I've left it simple in this patch). llvm-svn: 102407
2010-04-27 08:57:59 +08:00
Writer.AddTypeRef(T->getInjectedSpecializationType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_INJECTED_CLASS_NAME;
Create a new InjectedClassNameType to represent bare-word references to the injected class name of a class template or class template partial specialization. This is a non-canonical type; the canonical type is still a template specialization type. This becomes the TypeForDecl of the pattern declaration, which cleans up some amount of code (and complicates some other parts, but whatever). Fixes PR6326 and probably a few others, primarily by re-establishing a few invariants about TypeLoc sizes. llvm-svn: 98134
2010-03-10 11:28:59 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
Writer.AddDeclRef(T->getDecl(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_OBJC_INTERFACE;
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
}
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
void ASTTypeWriter::VisitObjCObjectType(const ObjCObjectType *T) {
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
Writer.AddTypeRef(T->getBaseType(), Record);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Record.push_back(T->getNumProtocols());
Substantially alter the design of the Objective C type AST by introducing ObjCObjectType, which is basically just a pair of one of {primitive-id, primitive-Class, user-defined @class} with a list of protocols. An ObjCObjectPointerType is therefore just a pointer which always points to one of these types (possibly sugared). ObjCInterfaceType is now just a kind of ObjCObjectType which happens to not carry any protocols. Alter a rather large number of use sites to use ObjCObjectType instead of ObjCInterfaceType. Store an ObjCInterfaceType as a pointer on the decl rather than hashing them in a FoldingSet. Remove some number of methods that are no longer used, at least after this patch. By simplifying ObjCObjectPointerType, we are now able to easily remove and apply pointers to Objective-C types, which is crucial for a certain kind of ObjC++ metaprogramming common in WebKit. llvm-svn: 103870
2010-05-15 19:32:37 +08:00
for (ObjCObjectType::qual_iterator I = T->qual_begin(),
Convert ObjC qualified type clients over to using iterators. This allows me to remove some API that I don't want to carry over to ObjCObjectPointerType. No functionality change. llvm-svn: 72475
2009-05-28 00:21:00 +08:00
E = T->qual_end(); I != E; ++I)
Writer.AddDeclRef(*I, Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_OBJC_OBJECT;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
First step toward fixing <rdar://problem/6613046> refactor clang objc type representation. Add a type (ObjCObjectPointerType) and remove a type (ObjCQualifiedIdType). This large/tedious patch is just a first step. Next step is to remove ObjCQualifiedInterfaceType. After that, I will remove the magic TypedefType for 'id' (installed by Sema). This work will enable various simplifications throughout clang (when dealing with ObjC types). No functionality change. llvm-svn: 73649
2009-06-18 06:40:22 +08:00
void
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Writer.AddTypeRef(T->getPointeeType(), Record);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = TYPE_OBJC_OBJECT_POINTER;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
namespace {
class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter &Writer;
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);
Writer.AddSourceLocation(TL.getLocalRangeEnd(), Record);
Implement the C++0x "trailing return type" feature, e.g., auto f(int) -> int from Daniel Wallin! (With a few minor bug fixes from me). llvm-svn: 115322
2010-10-02 02:44:50 +08:00
Record.push_back(TL.getTrailingReturn());
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
Writer.AddDeclRef(TL.getArg(i), Record);
}
void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
}
void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Add type source information for both kinds of typeof types. Patch by Enea Zaffanella. llvm-svn: 93344
2010-01-14 04:03:27 +08:00
Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
}
void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
Add type source information for both kinds of typeof types. Patch by Enea Zaffanella. llvm-svn: 93344
2010-01-14 04:03:27 +08:00
Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
Writer.AddSourceLocation(TL.getLParenLoc(), Record);
Writer.AddSourceLocation(TL.getRParenLoc(), Record);
Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
Clone the full Type hierarchy into the TypeLoc hierarchy. Normalize TypeLoc class names to be $(Type classname)Loc. Rewrite the visitor. Provide skeleton implementations for all the new TypeLocs. Handle all cases in PCH. Handle a few more cases when inserting location information in SemaType. It should be extremely straightforward to add new location information to existing TypeLoc objects now. llvm-svn: 84386
2009-10-18 09:05:36 +08:00
}
void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
Writer.AddSourceLocation(TL.getNameLoc(), Record);
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
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) {
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) {
Added basic source locations to Elaborated and DependentName types. llvm-svn: 104169
2010-05-20 05:37:53 +08:00
Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
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) {
Added basic source locations to Elaborated and DependentName types. llvm-svn: 104169
2010-05-20 05:37:53 +08:00
Writer.AddSourceLocation(TL.getKeywordLoc(), Record);
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) {
Writer.AddSourceLocation(TL.getKeywordLoc(), 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);
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.getNameLoc(), Record);
Writer.AddSourceLocation(TL.getLAngleLoc(), Record);
Writer.AddSourceLocation(TL.getRAngleLoc(), Record);
for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
-Introduce PCHReader::ReadTemplateArgumentLoc() -Introduce PCHWriter::AddTemplateArgumentLocInfo() -Modify PCHWriter::AddTemplateArgumentLoc() to also write TemplateArgumentLoc's TemplateArgument and move the existing calls of AddTemplateArgumentLoc() to AddTemplateArgumentLocInfo(). llvm-svn: 106533
2010-06-22 17:54:59 +08:00
Writer.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
TL.getArgLoc(I).getLocInfo(), Record);
Split DependentNameType into two types. DependentNameType represents the case of an elaborated-type-specifier like 'typename A<T>::foo', and DependentTemplateSpecializationType represents the case of an elaborated-type-specifier like 'typename A<T>::template B<T>'. The TypeLoc representation of a DependentTST conveniently exactly matches that of an ElaboratedType wrapping a TST. Kill off the explicit rebuild methods for RebuildInCurrentInstantiation; the standard implementations work fine because the nested name specifier is computable in the newly-entered context. llvm-svn: 105801
2010-06-11 08:33:02 +08:00
}
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
}
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);
RECORD(STMT_IF);
RECORD(STMT_SWITCH);
RECORD(STMT_WHILE);
RECORD(STMT_DO);
RECORD(STMT_FOR);
RECORD(STMT_GOTO);
RECORD(STMT_INDIRECT_GOTO);
RECORD(STMT_CONTINUE);
RECORD(STMT_BREAK);
RECORD(STMT_RETURN);
RECORD(STMT_DECL);
RECORD(STMT_ASM);
RECORD(EXPR_PREDEFINED);
RECORD(EXPR_DECL_REF);
RECORD(EXPR_INTEGER_LITERAL);
RECORD(EXPR_FLOATING_LITERAL);
RECORD(EXPR_IMAGINARY_LITERAL);
RECORD(EXPR_STRING_LITERAL);
RECORD(EXPR_CHARACTER_LITERAL);
RECORD(EXPR_PAREN);
RECORD(EXPR_UNARY_OPERATOR);
RECORD(EXPR_SIZEOF_ALIGN_OF);
RECORD(EXPR_ARRAY_SUBSCRIPT);
RECORD(EXPR_CALL);
RECORD(EXPR_MEMBER);
RECORD(EXPR_BINARY_OPERATOR);
RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
RECORD(EXPR_CONDITIONAL_OPERATOR);
RECORD(EXPR_IMPLICIT_CAST);
RECORD(EXPR_CSTYLE_CAST);
RECORD(EXPR_COMPOUND_LITERAL);
RECORD(EXPR_EXT_VECTOR_ELEMENT);
RECORD(EXPR_INIT_LIST);
RECORD(EXPR_DESIGNATED_INIT);
RECORD(EXPR_IMPLICIT_VALUE_INIT);
RECORD(EXPR_VA_ARG);
RECORD(EXPR_ADDR_LABEL);
RECORD(EXPR_STMT);
RECORD(EXPR_CHOOSE);
RECORD(EXPR_GNU_NULL);
RECORD(EXPR_SHUFFLE_VECTOR);
RECORD(EXPR_BLOCK);
RECORD(EXPR_BLOCK_DECL_REF);
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);
RECORD(EXPR_OBJC_ENCODE);
RECORD(EXPR_OBJC_SELECTOR_EXPR);
RECORD(EXPR_OBJC_PROTOCOL_EXPR);
RECORD(EXPR_OBJC_IVAR_REF_EXPR);
RECORD(EXPR_OBJC_PROPERTY_REF_EXPR);
RECORD(EXPR_OBJC_KVC_REF_EXPR);
RECORD(EXPR_OBJC_MESSAGE_EXPR);
RECORD(STMT_OBJC_FOR_COLLECTION);
RECORD(STMT_OBJC_CATCH);
RECORD(STMT_OBJC_FINALLY);
RECORD(STMT_OBJC_AT_TRY);
RECORD(STMT_OBJC_AT_SYNCHRONIZED);
RECORD(STMT_OBJC_AT_THROW);
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
RECORD(EXPR_CXX_OPERATOR_CALL);
RECORD(EXPR_CXX_CONSTRUCT);
RECORD(EXPR_CXX_STATIC_CAST);
RECORD(EXPR_CXX_DYNAMIC_CAST);
RECORD(EXPR_CXX_REINTERPRET_CAST);
RECORD(EXPR_CXX_CONST_CAST);
RECORD(EXPR_CXX_FUNCTIONAL_CAST);
RECORD(EXPR_CXX_BOOL_LITERAL);
RECORD(EXPR_CXX_NULL_PTR_LITERAL);
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
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// AST Top-Level Block.
Rename stuff in PCHBitCodes.h llvm-svn: 111475
2010-08-19 07:57:22 +08:00
BLOCK(AST_BLOCK);
emit ORIGINAL_FILE_NAME record ID to blockinfo block. llvm-svn: 72759
2009-06-03 17:23:28 +08:00
RECORD(ORIGINAL_FILE_NAME);
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
RECORD(ORIGINAL_FILE_ID);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(TYPE_OFFSET);
RECORD(DECL_OFFSET);
RECORD(LANGUAGE_OPTIONS);
Add a header containing the Clang version; make the driver use this Clang version value rather than hard-coding "1.0". Add PCH and Clang version information into the PCH file. Reject PCH files with the wrong version information. llvm-svn: 70264
2009-04-28 06:23:34 +08:00
RECORD(METADATA);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(IDENTIFIER_OFFSET);
RECORD(IDENTIFIER_TABLE);
RECORD(EXTERNAL_DEFINITIONS);
RECORD(SPECIAL_TYPES);
RECORD(STATISTICS);
RECORD(TENTATIVE_DEFINITIONS);
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
RECORD(UNUSED_FILESCOPED_DECLS);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(LOCALLY_SCOPED_EXTERNAL_DECLS);
RECORD(SELECTOR_OFFSETS);
RECORD(METHOD_POOL);
RECORD(PP_COUNTER_VALUE);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
RECORD(SOURCE_LOCATION_OFFSETS);
RECORD(SOURCE_LOCATION_PRELOADS);
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
RECORD(STAT_CACHE);
Add Sema::ExtVectorDecls and Sema::ObjCCategoryImpls to the PCH file. Since these vectors are very, very rarely used and, when used in headers, and even when used are relatively small, we load them eagerly. llvm-svn: 70240
2009-04-28 04:06:05 +08:00
RECORD(EXT_VECTOR_DECLS);
Rename pch::SVN_BRANCH_REVISION to pch::VERSION_CONTROL_BRANCH_REVISION. llvm-svn: 94214
2010-01-23 04:59:36 +08:00
RECORD(VERSION_CONTROL_BRANCH_REVISION);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
RECORD(MACRO_DEFINITION_OFFSETS);
Some preparatory work for chained PCH. No functionality change. llvm-svn: 107915
2010-07-09 06:01:51 +08:00
RECORD(CHAINED_METADATA);
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
RECORD(REFERENCED_SELECTOR_POOL);
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);
RECORD(REDECLS_UPDATE_LATEST);
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);
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(ORIGINAL_PCH_DIR);
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(FILE_SOURCE_LOCATION_OFFSETS);
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);
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
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);
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_CLASS);
RECORD(DECL_OBJC_FORWARD_PROTOCOL);
RECORD(DECL_OBJC_CATEGORY);
RECORD(DECL_OBJC_CATEGORY_IMPL);
RECORD(DECL_OBJC_IMPLEMENTATION);
RECORD(DECL_OBJC_COMPATIBLE_ALIAS);
RECORD(DECL_OBJC_PROPERTY);
RECORD(DECL_OBJC_PROPERTY_IMPL);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(DECL_FIELD);
RECORD(DECL_VAR);
add the decl names. llvm-svn: 70167
2009-04-27 06:32:16 +08:00
RECORD(DECL_IMPLICIT_PARAM);
make llvm-bcanalyzer dump out PCH files symbolically. We should probably eventually get an option to turn this off, but it is nice for looking at statistics. For example, the types block now prints: Block ID #11 (TYPES_BLOCK_ID): Num Instances: 1 Total Size: 895100b/111888B/27971.9W % of file: 1.55801 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 14899 % Abbrev Recs: 0 Code Histogram: 5478 TYPE_FUNCTION_PROTO 2683 TYPE_TYPEDEF 2460 TYPE_POINTER 2047 TYPE_ENUM 1553 TYPE_RECORD 283 TYPE_CONSTANT_ARRAY 274 TYPE_OBJC_INTERFACE 76 TYPE_INCOMPLETE_ARRAY 10 TYPE_VECTOR 9 TYPE_OBJC_QUALIFIED_ID 5 TYPE_FUNCTION_NO_PROTO 5 TYPE_EXT_QUAL 3 TYPE_TYPEOF_EXPR llvm-svn: 70166
2009-04-27 06:26:21 +08:00
RECORD(DECL_PARM_VAR);
add the decl names. llvm-svn: 70167
2009-04-27 06:32:16 +08:00
RECORD(DECL_FILE_SCOPE_ASM);
RECORD(DECL_BLOCK);
RECORD(DECL_CONTEXT_LEXICAL);
RECORD(DECL_CONTEXT_VISIBLE);
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
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the AST metadata (e.g., i686-apple-darwin9).
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
void ASTWriter::WriteMetadata(ASTContext &Context, StringRef isysroot,
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) {
Encode the target triple in the PCH file, and check that target triple when using the PCH file llvm-svn: 68824
2009-04-11 05:16:55 +08:00
using namespace llvm;
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// Metadata
const TargetInfo &Target = Context.Target;
BitCodeAbbrev *MetaAbbrev = new BitCodeAbbrev();
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
MetaAbbrev->Add(BitCodeAbbrevOp(
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Chain ? CHAINED_METADATA : METADATA));
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST major
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // AST minor
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang major
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Clang minor
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
// Target triple or chained PCH name
MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(Chain ? CHAINED_METADATA : METADATA);
Record.push_back(VERSION_MAJOR);
Record.push_back(VERSION_MINOR);
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Record.push_back(CLANG_VERSION_MAJOR);
Record.push_back(CLANG_VERSION_MINOR);
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());
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
// FIXME: This writes the absolute path for chained headers.
This patch extends the previous patch by starting to incorporate more functionality, like lookup-by-name and exporting lookup tables, into the module manager. Methods now have documentation. A few more functions have been switched over to the new iterator style and away from manual/explicit iteration. Ultimately we want to move away from name lookup here, as symlinks make filenames not a safe unique value, but we use it here as a stopgap before better measures are in place (namely instead using FileEntry* from a global FileManager). llvm-svn: 136107
2011-07-27 02:21:30 +08:00
const std::string &BlobStr =
Chain ? Chain->getFileName() : Target.getTriple().getTriple();
When given the -chained-pch option and a previous PCH file, have the PCHWriter emit a CHAINED_METADATA record instead of METADATA, and write a link to the previous file there. llvm-svn: 108014
2010-07-10 05:00:24 +08:00
Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, BlobStr);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
FileAbbrev->Add(BitCodeAbbrevOp(ORIGINAL_FILE_NAME));
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
FileAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
unsigned FileAbbrevCode = Stream.EmitAbbrev(FileAbbrev);
Replace all uses of PathV1::makeAbsolute with PathV2::fs::make_absolute. llvm-svn: 122340
2010-12-22 00:45:57 +08:00
llvm::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);
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(ORIGINAL_FILE_NAME);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(FileAbbrevCode, Record, MainFileNameStr);
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
Record.clear();
Record.push_back(SM.getMainFileID().getOpaqueValue());
Stream.EmitRecord(ORIGINAL_FILE_ID, Record);
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);
llvm::SmallString<128> OutputPath(OutputFile);
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);
}
(1) Rename getClangSubversionRevision() to getClangRevision(), and have it return a StringRef instead of an integer (to be more VCS agnostic). (2) Add getClangFullRepositoryVersion(), which contains an amalgamation of the repository name and the revision. (3) Change PCH to only emit the string returned by getClangFullRepositoryVersion() instead of also emitting the value of getClangSubversionRevision() (which has been removed). This is functionally equivalent. More cleanup to version string generation pending... llvm-svn: 94231
2010-01-23 06:12:47 +08:00
// Repository branch/version information.
BitCodeAbbrev *RepoAbbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
RepoAbbrev->Add(BitCodeAbbrevOp(VERSION_CONTROL_BRANCH_REVISION));
(1) Rename getClangSubversionRevision() to getClangRevision(), and have it return a StringRef instead of an integer (to be more VCS agnostic). (2) Add getClangFullRepositoryVersion(), which contains an amalgamation of the repository name and the revision. (3) Change PCH to only emit the string returned by getClangFullRepositoryVersion() instead of also emitting the value of getClangSubversionRevision() (which has been removed). This is functionally equivalent. More cleanup to version string generation pending... llvm-svn: 94231
2010-01-23 06:12:47 +08:00
RepoAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // SVN branch/tag
unsigned RepoAbbrevCode = Stream.EmitAbbrev(RepoAbbrev);
Encode the Clang branch and Subversion revision into a PCH file, and assume that PCH files from different Clang revisions are not compatible. Addresses <rdar://problem/7266572>. llvm-svn: 83323
2009-10-06 05:07:28 +08:00
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(VERSION_CONTROL_BRANCH_REVISION);
(1) Rename getClangSubversionRevision() to getClangRevision(), and have it return a StringRef instead of an integer (to be more VCS agnostic). (2) Add getClangFullRepositoryVersion(), which contains an amalgamation of the repository name and the revision. (3) Change PCH to only emit the string returned by getClangFullRepositoryVersion() instead of also emitting the value of getClangSubversionRevision() (which has been removed). This is functionally equivalent. More cleanup to version string generation pending... llvm-svn: 94231
2010-01-23 06:12:47 +08:00
Stream.EmitRecordWithBlob(RepoAbbrevCode, Record,
getClangFullRepositoryVersion());
Encode the target triple in the PCH file, and check that target triple when using the PCH file llvm-svn: 68824
2009-04-11 05:16:55 +08:00
}
/// \brief Write the LangOptions structure.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
RecordData Record;
Record.push_back(LangOpts.Trigraphs);
Record.push_back(LangOpts.BCPLComment); // BCPL-style '//' comments.
Record.push_back(LangOpts.DollarIdents); // '$' allowed in identifiers.
Record.push_back(LangOpts.AsmPreprocessor); // Preprocessor in asm mode.
Record.push_back(LangOpts.GNUMode); // True in gnu99 mode false in c99 mode (etc)
Add support for '-fgnu-keywords' and '-fasm' to Clang's driver. They are not implemented precisely the same as GCC, but the distinction GCC makes isn't useful to represent. This allows parsing code which uses GCC-specific keywords ('asm', etc.) without parsing in a fully GNU mode. llvm-svn: 101667
2010-04-18 04:17:31 +08:00
Record.push_back(LangOpts.GNUKeywords); // Allow GNU-extension keywords
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.ImplicitInt); // C89 implicit 'int'.
Record.push_back(LangOpts.Digraphs); // C94, C99 and C++
Record.push_back(LangOpts.HexFloats); // C99 Hexadecimal float constants.
Record.push_back(LangOpts.C99); // C99 Support
C1X: add a language standard llvm-svn: 129553
2011-04-15 08:35:23 +08:00
Record.push_back(LangOpts.C1X); // C1X Support
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Microsoft); // Microsoft extensions.
Reorganize predefined macros for all Windows targets. This adds an option to set the _MSC_VER macro without recompiling. This is very useful when testing compatibility with the Windows SDK and c++stdlib headers. -fmsc-version=<version> (defaults to VS2003 (1300)) llvm-svn: 116999
2010-10-21 13:21:48 +08:00
// LangOpts.MSCVersion is ignored because all it does it set a macro, which is
// already saved elsewhere.
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.CPlusPlus); // C++ Support
Record.push_back(LangOpts.CPlusPlus0x); // C++0x Support
Record.push_back(LangOpts.CXXOperatorNames); // Treat C++ operator names as keywords.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.ObjC1); // Objective-C 1 support enabled.
Record.push_back(LangOpts.ObjC2); // Objective-C 2 support enabled.
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Record.push_back(LangOpts.ObjCNonFragileABI); // Objective-C
Implement synthesizing properties by default. This is a non-fragile-abi feature only. Since it breaks existing code, it is currently placed under -fobjc-nonfragile-abi2 option for test purposes only until further notice. WIP. llvm-svn: 95685
2010-02-10 03:31:38 +08:00
// modern abi enabled.
Use makeAbsolute() llvm-svn: 98472
2010-03-14 15:06:50 +08:00
Record.push_back(LangOpts.ObjCNonFragileABI2); // Objective-C enhanced
Implement synthesizing properties by default. This is a non-fragile-abi feature only. Since it breaks existing code, it is currently placed under -fobjc-nonfragile-abi2 option for test purposes only until further notice. WIP. llvm-svn: 95685
2010-02-10 03:31:38 +08:00
// modern abi enabled.
Update AST reader/writer to handle new AppleKext. Fix an unexpected hickup caused by exceeding size of generated table (and a misleading comment). Improve on help message for -fapple-kext. llvm-svn: 123003
2011-01-08 02:59:25 +08:00
Record.push_back(LangOpts.AppleKext); // Apple's kernel extensions ABI
Add -fobjc-default-synthesized-properties flag to allow us to explicitly control whether or not Objective-C properties are default synthesized. Currently this feature only works when using the -fobjc-non-fragile-abi2 flag (so there is no functionality change), but we can now turn off this feature without turning off all the features coupled with -fobjc-non-fragile-abi2. llvm-svn: 122519
2010-12-24 05:35:43 +08:00
Record.push_back(LangOpts.ObjCDefaultSynthProperties); // Objective-C auto-synthesized
// properties enabled.
Introduce a -cc1-level option to turn off related result type inference, to be used (only) by the Objective-C rewriter. llvm-svn: 133025
2011-06-15 07:20:43 +08:00
Record.push_back(LangOpts.ObjCInferRelatedResultType);
Check for -fno-constant-cfstrings consistency in pch. llvm-svn: 102130
2010-04-23 05:01:59 +08:00
Record.push_back(LangOpts.NoConstantCFStrings); // non cfstring generation enabled..
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.PascalStrings); // Allow Pascal strings
Record.push_back(LangOpts.WritableStrings); // Allow writable strings
Record.push_back(LangOpts.LaxVectorConversions);
Write/Read new Language Options llvm-svn: 74221
2009-06-26 07:01:11 +08:00
Record.push_back(LangOpts.AltiVec);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Exceptions); // Support exception handling.
Add a new ObjCExceptions member variable to LangOptions. This controls whether Objective-C exceptions are enabled or not (they are by default). llvm-svn: 126061
2011-02-20 07:53:54 +08:00
Record.push_back(LangOpts.ObjCExceptions);
Add a CXXExceptions flag to LangOptions. llvm-svn: 126299
2011-02-23 11:04:54 +08:00
Record.push_back(LangOpts.CXXExceptions);
Record.push_back(LangOpts.SjLjExceptions);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Basic support for -mms-bitfields, from Carl Norum! llvm-svn: 124661
2011-02-01 23:15:22 +08:00
Record.push_back(LangOpts.MSBitfields); // MS-compatible structure layout
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.NeXTRuntime); // Use NeXT runtime.
Record.push_back(LangOpts.Freestanding); // Freestanding implementation
Record.push_back(LangOpts.NoBuiltin); // Do not use builtin functions (-fno-builtin)
add an abbreviation for common PARM_VAR_DECL. All but 9 of the parm var decls in leopard cocoa.h end up using this abbreviation, which shrinks the bitcode file by about 50K: 7217736->7167120. Before: Block ID #12 (DECLS_BLOCK): Num Instances: 1 Total Size: 2.23595e+07b/2.79494e+06B/698736W % of file: 38.7233 Num SubBlocks: 0 Num Abbrevs: 0 Num Records: 139387 % Abbrev Recs: 0 After: Block ID #12 (DECLS_BLOCK): Num Instances: 1 Total Size: 2.02405e+07b/2.53006e+06B/632516W % of file: 35.301 Num SubBlocks: 0 Num Abbrevs: 1 Num Records: 139387 % Abbrev Recs: 19.2902 llvm-svn: 70199
2009-04-27 15:35:58 +08:00
// Whether static initializers are protected by locks.
Record.push_back(LangOpts.ThreadsafeStatics);
Save/load POSIXThreads flag for PCH llvm-svn: 80916
2009-09-03 22:36:33 +08:00
Record.push_back(LangOpts.POSIXThreads);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Blocks); // block extension to C
Record.push_back(LangOpts.EmitAllDecls); // Emit all declarations, even if
// they are unused.
Record.push_back(LangOpts.MathErrno); // Math functions must respect errno
// (modulo the platform support).
Implement support for -fwrapv, rdar://7221421 As part of this, pull together trapv handling into the same enum. This also add support for NSW multiplies. This also makes PCH disagreement on overflow behavior silent, since it really doesn't matter except for warnings and codegen (no macros get defined etc). llvm-svn: 106956
2010-06-27 05:25:03 +08:00
Record.push_back(LangOpts.getSignedOverflowBehavior());
Record.push_back(LangOpts.HeinousExtensions);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.Optimize); // Whether __OPTIMIZE__ should be defined.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Record.push_back(LangOpts.OptimizeSize); // Whether __OPTIMIZE_SIZE__ should be
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
// defined.
Record.push_back(LangOpts.Static); // Should __STATIC__ be defined (as
// opposed to __DYNAMIC__).
Record.push_back(LangOpts.PICLevel); // The value for __PIC__, if non-zero.
Record.push_back(LangOpts.GNUInline); // Should GNU inline semantics be
// used (instead of C99 semantics).
Record.push_back(LangOpts.NoInline); // Should __NO_INLINE__ be defined.
Teach the AST reader and writer to preserve the __DEPRECATED bit in language options, and warn when reading an AST with a different value for the bit. There doesn't appear to be a good way to test this (commenting out similar other language options doesn't break anything) but if folks have suggestions on tests I'm happy to add them. llvm-svn: 130071
2011-04-24 04:05:38 +08:00
Record.push_back(LangOpts.Deprecated); // Should __DEPRECATED be defined.
Disable access control by default. It can be enabled with the -faccess-control option. When we have better support for it, we can enable it by default again. llvm-svn: 71706
2009-05-14 03:49:53 +08:00
Record.push_back(LangOpts.AccessControl); // Whether C++ access control should
// be enabled.
Move CharIsSigned from TargetInfo to LangOptions. llvm-svn: 72928
2009-06-05 15:05:05 +08:00
Record.push_back(LangOpts.CharIsSigned); // Whether char is a signed or
// unsigned type
Adding -fshort-wchar option. llvm-svn: 86167
2009-11-06 04:14:16 +08:00
Record.push_back(LangOpts.ShortWChar); // force wchar_t to be unsigned short
Store/retrieve -fshort-enums for PCH, fixes rdar://8854933. llvm-svn: 123510
2011-01-15 10:56:16 +08:00
Record.push_back(LangOpts.ShortEnums); // Should the enum type be equivalent
// to the smallest integer type with
// enough room.
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.getGCMode());
Record.push_back(LangOpts.getVisibilityMode());
Add missing PCH support for -fstack-protector. llvm-svn: 82435
2009-09-21 12:16:19 +08:00
Record.push_back(LangOpts.getStackProtectorMode());
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
Record.push_back(LangOpts.InstantiationDepth);
Write/Read new Language Options llvm-svn: 74221
2009-06-26 07:01:11 +08:00
Record.push_back(LangOpts.OpenCL);
Serialization: support for CUDA language extensions llvm-svn: 120588
2010-12-02 03:14:57 +08:00
Record.push_back(LangOpts.CUDA);
Implement runtime checks for undefined behavior. WIP. This implements a new flag -fcatch-undefined-behavior. The flag turns on additional runtime checks for: T a[I]; a[i] abort when i < 0 or i >= I. Future stuff includes shifts by >= bitwidth amounts. llvm-svn: 91198
2009-12-12 09:27:46 +08:00
Record.push_back(LangOpts.CatchUndefined);
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.push_back(LangOpts.DefaultFPContract);
Add a -fno-elide-constructors option to clang-cc. llvm-svn: 79782
2009-08-23 06:30:33 +08:00
Record.push_back(LangOpts.ElideConstructors);
Introduce -f{no-}spell-checking options to enable/disable spell-checking. By default, spell-checking is enabled for Clang (obviously) but disabled in CIndex for performance reasons. llvm-svn: 107992
2010-07-10 01:35:33 +08:00
Record.push_back(LangOpts.SpellChecking);
Implement -mrtd which sets the StdCall calling convention to be the default one. llvm-svn: 126756
2011-03-02 01:40:53 +08:00
Record.push_back(LangOpts.MRTD);
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(LangOpts.ObjCAutoRefCount);
Record.push_back(LangOpts.ObjCInferRelatedReturnType);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(LANGUAGE_OPTIONS, Record);
Implement serialization/deserialization of LangOptions in the PCH file. When de-serializing LangOptions, we check that the currently-provided language options are consistent with the options used to compile the PCH file. If they are not, we emit a diagnostic and ignore the PCH file. llvm-svn: 68820
2009-04-11 04:39:37 +08:00
}
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
//===----------------------------------------------------------------------===//
// stat cache Serialization
//===----------------------------------------------------------------------===//
namespace {
// Trait used for the on-disk hash table of stat cache results.
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
class ASTStatCacheTrait {
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
public:
typedef const char * key_type;
typedef key_type key_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the stat() system call cache to the AST file.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) {
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
// Build the on-disk hash table containing information about every
// stat() call.
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
OnDiskChainedHashTableGenerator<ASTStatCacheTrait> Generator;
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
unsigned NumStatEntries = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (MemorizeStatCalls::iterator Stat = StatCalls.begin(),
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
StatEnd = StatCalls.end();
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Stat != StatEnd; ++Stat, ++NumStatEntries) {
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 Filename = Stat->first();
StringMap::first() is about to start returning a StringRef, adapt. llvm-svn: 135166
2011-07-15 02:24:21 +08:00
Generator.insert(Filename.data(), Stat->second);
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
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
// Create the on-disk hash table in a buffer.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallString<4096> StatCacheData;
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(StatCacheData);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out);
}
// Create a blob abbreviation
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(STAT_CACHE));
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned StatCacheAbbrev = Stream.EmitAbbrev(Abbrev);
// Write the stat cache
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(STAT_CACHE);
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
Record.push_back(BucketOffset);
Record.push_back(NumStatEntries);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(StatCacheAbbrev, Record, StatCacheData.str());
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
}
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
//===----------------------------------------------------------------------===//
// Source Manager Serialization
//===----------------------------------------------------------------------===//
/// \brief Create an abbreviation for the SLocEntry that refers to a
/// file.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_FILE_ENTRY));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
Keep track of the size/modification time of each file source-location entry in a precompiled header, so that we can detect modified files even when we miss in the stat cache. llvm-svn: 99149
2010-03-22 06:49:54 +08:00
// FileEntry fields.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 12)); // Size
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 32)); // Modification time
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
/// \brief Create an abbreviation for the SLocEntry that refers to a
/// buffer.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_ENTRY));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Offset
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Include location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
/// \brief Create an abbreviation for the SLocEntry that refers to a
/// buffer's blob.
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SM_SLOC_BUFFER_BLOB));
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
return Stream.EmitAbbrev(Abbrev);
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
}
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;
HeaderSearch &HS;
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:
HeaderFileInfoTrait(ASTWriter &Writer, HeaderSearch &HS)
: Writer(Writer), HS(HS) { }
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.
///
/// \param Chain Whether we're creating a chained AST file.
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
void ASTWriter::WriteHeaderSearch(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());
HeaderFileInfoTrait GeneratorTrait(*this, HS);
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;
const HeaderFileInfo &HFI = HS.header_file_begin()[UID];
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.
llvm::SmallString<4096> TableData;
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;
[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
// Write out the offsets of only source location file entries.
// We will go through them in ASTReader::validateFileEntries().
std::vector<uint32_t> SLocFileEntryOffsets;
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);
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()) {
[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
if (SLoc->getFile().getContentCache()->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
SLocFileEntryOffsets.push_back(Stream.GetCurrentBitNo());
} 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 &&
"Writing to AST an overriden file is not supported");
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
// The source location entry is a file. The blob associated
// with this entry is the file name.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Keep track of the size/modification time of each file source-location entry in a precompiled header, so that we can detect modified files even when we miss in the stat cache. llvm-svn: 99149
2010-03-22 06:49:54 +08:00
// Emit size/modification time for this file.
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
Record.push_back(Content->OrigEntry->getSize());
Record.push_back(Content->OrigEntry->getModificationTime());
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
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
// Turn the file name into an absolute path, if it isn't already.
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
const char *Filename = Content->OrigEntry->getName();
Replace all uses of PathV1::makeAbsolute with PathV2::fs::make_absolute. llvm-svn: 122340
2010-12-22 00:45:57 +08:00
llvm::SmallString<128> FilePath(Filename);
When writing file references in a pch, make sure to ask the file manager for the absolute path. llvm-svn: 127248
2011-03-09 00:04:35 +08:00
// 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.
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(FilePath);
Path related cleanup. Remove unnecessary variables. llvm-svn: 98473
2010-03-14 15:15:57 +08:00
Filename = FilePath.c_str();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Filename = adjustFilenameForRelocatablePCH(Filename, isysroot);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename);
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());
Record.push_back(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
[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
Abbrev = new BitCodeAbbrev();
Abbrev->Add(BitCodeAbbrevOp(FILE_SOURCE_LOCATION_OFFSETS));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // # of slocs
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets
unsigned SLocFileOffsetsAbbrev = Stream.EmitAbbrev(Abbrev);
Record.clear();
Record.push_back(FILE_SOURCE_LOCATION_OFFSETS);
Record.push_back(SLocFileEntryOffsets.size());
Stream.EmitRecordWithBlob(SLocFileOffsetsAbbrev, Record,
data(SLocFileEntryOffsets));
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.
if (L->first < 0)
continue;
// Emit the file ID
Record.push_back(L->first);
// 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.
///
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WritePreprocessor(const Preprocessor &PP) {
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
RecordData Record;
implement the microsoft/gnu "__COUNTER__" macro: rdar://4329310 llvm-svn: 68933
2009-04-13 09:29:17 +08:00
// If the preprocessor __COUNTER__ value has been bumped, remember it.
if (PP.getCounterValue() != 0) {
Record.push_back(PP.getCounterValue());
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(PP_COUNTER_VALUE, Record);
implement the microsoft/gnu "__COUNTER__" macro: rdar://4329310 llvm-svn: 68933
2009-04-13 09:29:17 +08:00
Record.clear();
Don't read all of the records in the PCH file's preprocessor block, most of which are ignored. Instead, move the __COUNTER__ value out to a PCH-level record (since it is handled eagerly) and move the header file information into the SourceManager block (which is also, currently, loaded eagerly). This results in another 17% performance improvement in the Cocoa-prefixed "Hello, World" with PCH. llvm-svn: 70097
2009-04-26 08:07:37 +08:00
}
// Enter the preprocessor block.
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.
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
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;
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
for (Preprocessor::macro_iterator I = PP.macro_begin(Chain == 0),
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) {
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
MacroDefinitionsSeen.insert(I->first);
MacrosToEmit.push_back(std::make_pair(I->first, I->second));
}
// Sort the set of macro definitions that need to be serialized by the
// name of the macro, to provide a stable ordering.
llvm::array_pod_sort(MacrosToEmit.begin(), MacrosToEmit.end(),
&compareMacroDefinitions);
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
// Resolve any identifiers that defined macros at the time they were
// deserialized, adding them to the list of macros to emit (if appropriate).
for (unsigned I = 0, N = DeserializedMacroNames.size(); I != N; ++I) {
IdentifierInfo *Name
= const_cast<IdentifierInfo *>(DeserializedMacroNames[I]);
if (Name->hasMacroDefinition() && MacroDefinitionsSeen.insert(Name))
MacrosToEmit.push_back(std::make_pair(Name, PP.getMacroInfo(Name)));
}
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;
MacroInfo *MI = MacrosToEmit[I].second;
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
if (!MI)
continue;
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Don't emit builtin macros like __LINE__ to the AST file unless they have
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
// been redefined by the header (in which case they are not isBuiltinMacro).
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// Also skip macros from a AST file if we're chaining.
When an identifier that has a macro definition in the original PCH file is somehow changed in a chained PCH file, make sure that we write out the macro definition. Fixes part of <rdar://problem/8499034>. llvm-svn: 115259
2010-10-01 09:03:07 +08:00
// FIXME: There is a (probably minor) optimization we could do here, if
// the macro comes from the original PCH but the identifier comes from a
// chained PCH, by storing the offset into the original PCH rather than
// writing the macro definition a second time.
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
if (MI->isBuiltinMacro() ||
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
(Chain && Name->isFromAST() && MI->isFromAST()))
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
continue;
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
AddIdentifierRef(Name, Record);
MacroOffsets[Name] = Stream.GetCurrentBitNo();
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
Record.push_back(MI->getDefinitionLoc().getRawEncoding());
Record.push_back(MI->isUsed());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
unsigned Code;
if (MI->isObjectLike()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = PP_MACRO_OBJECT_LIKE;
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
} else {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Code = PP_MACRO_FUNCTION_LIKE;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
Record.push_back(MI->isC99Varargs());
Record.push_back(MI->isGNUVarargs());
Record.push_back(MI->getNumArgs());
for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
I != E; ++I)
now that we have an identifier table in the PCH file, finish hooking up macro deserialization. We now correctly install II's in tokens, handle function-like macros, etc. llvm-svn: 68882
2009-04-12 05:15:38 +08:00
AddIdentifierRef(*I, Record);
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
}
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 we have a detailed preprocessing record, record the macro definition
// ID that corresponds to this macro.
if (PPRec)
Record.push_back(getMacroDefinitionID(PPRec->findMacroDefinition(MI)));
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
Stream.EmitRecord(Code, Record);
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
Record.clear();
improve punctuation llvm-svn: 68791
2009-04-11 01:16:57 +08:00
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
// Emit the tokens array.
for (unsigned TokNo = 0, e = MI->getNumTokens(); TokNo != e; ++TokNo) {
// Note that we know that the preprocessor does not have any annotation
// tokens in it because they are created by the parser, and thus can't be
// in a macro definition.
const Token &Tok = MI->getReplacementToken(TokNo);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
Record.push_back(Tok.getLocation().getRawEncoding());
Record.push_back(Tok.getLength());
// FIXME: When reading literal tokens, reconstruct the literal pointer if
// it is needed.
now that we have an identifier table in the PCH file, finish hooking up macro deserialization. We now correctly install II's in tokens, handle function-like macros, etc. llvm-svn: 68882
2009-04-12 05:15:38 +08:00
AddIdentifierRef(Tok.getIdentifierInfo(), Record);
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
// FIXME: Should translate token kind to a stable encoding.
Record.push_back(Tok.getKind());
// FIXME: Should translate token flags to a stable encoding.
Record.push_back(Tok.getFlags());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(PP_TOKEN, Record);
emit tokens, constify the Preprocessor passed down into PCH writer. llvm-svn: 68798
2009-04-11 02:08:30 +08:00
Record.clear();
}
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
++NumMacros;
emit function-like and object-like macros to the PCH file. Note that we don't do anything useful with identifier infos yet and don't emit the tokens that the macros are defined to. llvm-svn: 68797
2009-04-11 02:00:12 +08:00
}
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();
if (PPRec)
WritePreprocessorDetail(*PPRec);
}
void ASTWriter::WritePreprocessorDetail(PreprocessingRecord &PPRec) {
if (PPRec.begin(Chain) == PPRec.end(Chain))
return;
// 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)); // index
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // start location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // end location
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // filename length
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // in quotes
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // kind
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 a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
uint64_t BitsInChain = Chain? Chain->TotalModulesSizeInBits : 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
for (PreprocessingRecord::iterator E = PPRec.begin(Chain),
EEnd = PPRec.end(Chain);
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
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)) {
// Record this macro definition's location.
MacroID ID = getMacroDefinitionID(MD);
// Don't write the macro definition if it is from another AST file.
if (ID < FirstMacroID)
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
continue;
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
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
// Notify the serialization listener that we're serializing this entity.
if (SerializationListener)
SerializationListener->SerializedPreprocessedEntity(*E,
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
BitsInChain + Stream.GetCurrentBitNo());
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
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
unsigned Position = ID - FirstMacroID;
if (Position != MacroDefinitionOffsets.size()) {
if (Position > MacroDefinitionOffsets.size())
MacroDefinitionOffsets.resize(Position + 1);
MacroDefinitionOffsets[Position] = Stream.GetCurrentBitNo();
} else
MacroDefinitionOffsets.push_back(Stream.GetCurrentBitNo());
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
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
Record.push_back(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.push_back(ID);
AddSourceLocation(MD->getSourceRange().getBegin(), Record);
AddSourceLocation(MD->getSourceRange().getEnd(), Record);
AddIdentifierRef(MD->getName(), Record);
AddSourceLocation(MD->getLocation(), Record);
Stream.EmitRecord(PPD_MACRO_DEFINITION, Record);
continue;
}
// Notify the serialization listener that we're serializing this entity.
if (SerializationListener)
SerializationListener->SerializedPreprocessedEntity(*E,
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
BitsInChain + Stream.GetCurrentBitNo());
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
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)) {
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
Record.push_back(NextPreprocessorEntityID);
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
AddSourceLocation(ME->getSourceRange().getBegin(), Record);
AddSourceLocation(ME->getSourceRange().getEnd(), Record);
AddIdentifierRef(ME->getName(), Record);
Record.push_back(getMacroDefinitionID(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);
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
Record.push_back(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
AddSourceLocation(ID->getSourceRange().getBegin(), Record);
AddSourceLocation(ID->getSourceRange().getEnd(), Record);
Record.push_back(ID->getFileName().size());
Record.push_back(ID->wasInQuotes());
Record.push_back(static_cast<unsigned>(ID->getKind()));
llvm::SmallString<64> Buffer;
Buffer += ID->getFileName();
Buffer += ID->getFile()->getName();
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) {
// Write the offsets table for identifier IDs.
using namespace llvm;
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(MACRO_DEFINITION_OFFSETS));
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of records
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::Fixed, 32)); // # of macro defs
Implement the local -> global remapping for macro definition IDs in the detailed preprocessing record. Tested with the standard "gaps" method. llvm-svn: 136882
2011-08-05 00:36:56 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first macro def
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));
unsigned MacroDefOffsetAbbrev = 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();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(MACRO_DEFINITION_OFFSETS);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Record.push_back(NumPreprocessingRecords);
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);
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
Record.push_back(MacroDefinitionOffsets.size());
Implement the local -> global remapping for macro definition IDs in the detailed preprocessing record. Tested with the standard "gaps" method. llvm-svn: 136882
2011-08-05 00:36:56 +08:00
Record.push_back(FirstMacroID - NUM_PREDEF_MACRO_IDS);
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
Stream.EmitRecordWithBlob(MacroDefOffsetAbbrev, 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(MacroDefinitionOffsets));
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
}
Arrange for the preprocessor to be passed down into the PCH writer. llvm-svn: 68790
2009-04-11 01:15:23 +08:00
}
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
void ASTWriter::WritePragmaDiagnosticMappings(const Diagnostic &Diag) {
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;
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
for (Diagnostic::DiagStatePointsTy::const_iterator
I = Diag.DiagStatePoints.begin(), E = Diag.DiagStatePoints.end();
I != E; ++I) {
const Diagnostic::DiagStatePoint &point = *I;
if (point.Loc.isInvalid())
continue;
Record.push_back(point.Loc.getRawEncoding());
for (Diagnostic::DiagState::iterator
I = point.State->begin(), E = point.State->end(); I != E; ++I) {
unsigned diag = I->first, map = I->second;
if (map & 0x10) { // mapping from a diagnostic pragma.
Record.push_back(diag);
Record.push_back(map & 0x7);
}
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
}
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
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
}
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) {
if (M->Method->getPCHLevel() == 0)
changed = true;
}
for (ObjCMethodList *M = &Data.Factory; !changed && M && M->Method;
M = M->Next) {
if (M->Method->getPCHLevel() == 0)
changed = true;
}
if (!changed)
continue;
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
} else if (Data.Instance.Method || Data.Factory.Method) {
// A new method pool entry.
++NumTableEntries;
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
}
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
Generator.insert(S, Data, Trait);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
}
// Create the on-disk hash table in a buffer.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallString<4096> MethodPool;
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
uint32_t BucketOffset;
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTMethodPoolTrait Trait(*this);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
llvm::raw_svector_ostream Out(MethodPool);
// Make sure that no bucket is at offset 0
Fix two small but very nasty bugs in the PCH writer for method pools: (1) Make sure to pad on-disk hash tables with 4 bytes, not 2, since the reader assumes that bucket data is aligned on 4-byte boundaries. (2) Don't emit the number of factory methods twice. This was throwing off the data counts and therefore causing lookups to fail. I've added asserts so that this class of error cannot happen again. llvm-svn: 69991
2009-04-25 05:49:02 +08:00
clang::io::Emit32(Out, 0);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
BucketOffset = Generator.Emit(Out, Trait);
}
// Create a blob abbreviation
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
unsigned MethodPoolAbbrev = Stream.EmitAbbrev(Abbrev);
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
// Write the method pool
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(METHOD_POOL);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
Record.push_back(BucketOffset);
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
Record.push_back(NumTableEntries);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(MethodPoolAbbrev, Record, MethodPool.str());
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
// Create a blob abbreviation for the selector table offsets.
Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(SELECTOR_OFFSETS));
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;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
/// \brief Determines whether this is an "interesting" identifier
/// that needs a full IdentifierInfo structure written into the hash
/// table.
static bool isInterestingIdentifier(const IdentifierInfo *II) {
return II->isPoisoned() ||
II->isExtensionToken() ||
II->hasMacroDefinition() ||
II->getObjCOrBuiltinID() ||
II->getFETokenInfo<void>();
}
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
public:
typedef const IdentifierInfo* key_type;
typedef key_type key_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
typedef IdentID data_type;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
typedef data_type data_type_ref;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP)
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
: Writer(Writer), PP(PP) { }
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
static unsigned ComputeHash(const IdentifierInfo* II) {
Switch to llvm::HashString. llvm-svn: 84375
2009-10-18 07:52:28 +08:00
return llvm::HashString(II->getName());
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<unsigned,unsigned>
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 IdentifierInfo* II,
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ID) {
Move clients to use IdentifierInfo::getNameStart() instead of getName() llvm-svn: 84436
2009-10-19 04:26:12 +08:00
unsigned KeyLen = II->getLength() + 1;
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
unsigned DataLen = 4; // 4 bytes for the persistent ID << 1
if (isInterestingIdentifier(II)) {
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
DataLen += 2; // 2 bytes for builtin ID, flags
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (II->hasMacroDefinition() &&
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
!PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro())
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
DataLen += 4;
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
for (IdentifierResolver::iterator D = IdentifierResolver::begin(II),
DEnd = IdentifierResolver::end();
D != DEnd; ++D)
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DataLen += sizeof(DeclID);
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
}
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
clang::io::Emit16(Out, DataLen);
Revert r70075 and r70078, which reorganized the PCH on-disk hash table for identifiers to separate "interesting" from "uninteresting" identifiers. However, to cope with compiler invocations where the predefines buffers mismatch, we need to be able to search the complete identifier table. Cocoa.h.pch is now about 500k larger that it used to be :( llvm-svn: 70320
2009-04-29 04:01:51 +08:00
// We emit the key length after the data length so that every
// string is preceded by a 16-bit length. This matches the PTH
// format for storing identifiers.
PCH optimization for the identifier table, where we separate "interesting" identifiers (e.g., those where the IdentifierInfo has some useful information) from "uninteresting" identifiers (where the IdentifierInfo is just a name). This makes the hash table smaller (so searching in it should be faster) and, when loading "uninteresting" identifiers, we skip the lookup in the hash table. PCH file size is slightly smaller than before (since we don't emit the contents of the uninteresting IdentifierInfo structures). The Cocoa.h-prefixed "Hello, World" doesn't show any speedup, although we're getting to the point where system noise is a bit issue. llvm-svn: 70075
2009-04-26 05:04:17 +08:00
clang::io::Emit16(Out, KeyLen);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
return std::make_pair(KeyLen, DataLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
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, const IdentifierInfo* II,
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ID, unsigned) {
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
if (!isInterestingIdentifier(II)) {
clang::io::Emit32(Out, ID << 1);
return;
}
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
Implement a minor space optimization for the PCH identifier table, which eliminates the storage for IdentifierInfo in the "uninteresting identifier" cases. Sadly, this only brought back 7k of the 500k we lost :( llvm-svn: 70325
2009-04-29 05:18:29 +08:00
clang::io::Emit32(Out, (ID << 1) | 0x01);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
uint32_t Bits = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
bool hasMacroDefinition =
II->hasMacroDefinition() &&
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
!PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro();
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
Bits = (uint32_t)II->getObjCOrBuiltinID();
Fix a few MSVC warnings. llvm-svn: 91714
2009-12-19 04:58:47 +08:00
Bits = (Bits << 1) | unsigned(hasMacroDefinition);
Bits = (Bits << 1) | unsigned(II->isExtensionToken());
Bits = (Bits << 1) | unsigned(II->isPoisoned());
-Make TokenID of IdentifierInfo read-only, remove setTokenID(). -There are 2 instances that change the TokenID for GNU libstdc++ 4.2 compatibility. To handler those cases introduce a RevertedTokenID bitfield, RevertTokenIDToIdentifier() and hasRevertedTokenIDToIdentifier() methods. Store the bitfield in PCH. llvm-svn: 110868
2010-08-12 06:55:12 +08:00
Bits = (Bits << 1) | unsigned(II->hasRevertedTokenIDToIdentifier());
Fix a few MSVC warnings. llvm-svn: 91714
2009-12-19 04:58:47 +08:00
Bits = (Bits << 1) | unsigned(II->isCPlusPlusOperatorKeyword());
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
clang::io::Emit16(Out, Bits);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
if (hasMacroDefinition)
Optimize IdentifierInfo storage within the precompiled header. We've now gotten back about 180k of the 500k we lost. llvm-svn: 70326
2009-04-29 05:32:13 +08:00
clang::io::Emit32(Out, Writer.getMacroOffset(II));
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
// Emit the declaration IDs in reverse order, because the
// IdentifierResolver provides the declarations as they would be
// visible (e.g., the function "stat" would come before the struct
// "stat"), but IdentifierResolver::AddDeclToIdentifierChain()
// adds declarations to the end of the list (so we need to see the
// struct "status" before the function "status").
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
// Only emit declarations that aren't from a chained PCH, though.
remove 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<Decl *, 16> Decls(IdentifierResolver::begin(II),
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
IdentifierResolver::end());
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(),
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
DEnd = Decls.rend();
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
D != DEnd; ++D)
Query only the latest version of an identifier in the PCH chain. Make sure this version holds the entire declaration chain. This is a much saner solution than trying to merge the info from all elements, and makes redeclarations work properly. Expand the declarations test case to cover more compliated cases. llvm-svn: 110052
2010-08-03 02:30:12 +08:00
clang::io::Emit32(Out, Writer.getDeclID(*D));
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
};
} // end anonymous namespace
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// \brief Write the identifier table into the AST file.
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
///
/// The identifier table consists of a blob containing string data
/// (the actual identifiers themselves) and a separate "offsets" index
/// that maps identifier IDs to locations within the blob.
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteIdentifierTable(Preprocessor &PP) {
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
using namespace llvm;
// Create and write out the blob that contains the identifier
// strings.
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
ASTIdentifierTableTrait Trait(*this, PP);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement checking for macro definitions that occur on the command line when using a PCH that were not provided when building the PCH file. If those names were used as identifiers somewhere in the PCH file, reject the PCH file. llvm-svn: 70321
2009-04-29 04:33:11 +08:00
// Look for any identifiers that were named while processing the
// headers, but are otherwise not needed. We add these to the hash
// table to enable checking of the predefines buffer in the case
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
// where the user adds new macro definitions when building the AST
Implement checking for macro definitions that occur on the command line when using a PCH that were not provided when building the PCH file. If those names were used as identifiers somewhere in the PCH file, reject the PCH file. llvm-svn: 70321
2009-04-29 04:33:11 +08:00
// file.
for (IdentifierTable::iterator ID = PP.getIdentifierTable().begin(),
IDEnd = PP.getIdentifierTable().end();
ID != IDEnd; ++ID)
getIdentifierRef(ID->second);
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
// Create the on-disk hash table representation. We only store offsets
// for identifiers that appear here for the first time.
IdentifierOffsets.resize(NextIdentID - FirstIdentID);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
for (llvm::DenseMap<const IdentifierInfo *, IdentID>::iterator
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
ID = IdentifierIDs.begin(), IDEnd = IdentifierIDs.end();
ID != IDEnd; ++ID) {
assert(ID->first && "NULL identifier in identifier table");
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
if (!Chain || !ID->first->isFromAST())
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
Generator.insert(ID->first, ID->second, Trait);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
}
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
// Create the on-disk hash table in a buffer.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
llvm::SmallString<4096> IdentifierTable;
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
uint32_t BucketOffset;
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
{
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
ASTIdentifierTableTrait Trait(*this, PP);
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
llvm::raw_svector_ostream Out(IdentifierTable);
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
// Make sure that no bucket is at offset 0
Fix two small but very nasty bugs in the PCH writer for method pools: (1) Make sure to pad on-disk hash tables with 4 bytes, not 2, since the reader assumes that bucket data is aligned on 4-byte boundaries. (2) Don't emit the number of factory methods twice. This was throwing off the data counts and therefore causing lookups to fail. I've added asserts so that this class of error cannot happen again. llvm-svn: 69991
2009-04-25 05:49:02 +08:00
clang::io::Emit32(Out, 0);
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
BucketOffset = Generator.Emit(Out, Trait);
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
}
// Create a blob abbreviation
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. llvm-svn: 69319
2009-04-17 06:23:12 +08:00
unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev);
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
// Write the identifier table
RecordData Record;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Record.push_back(IDENTIFIER_TABLE);
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
Record.push_back(BucketOffset);
Switch to StringRef based BitstreamWriter APIs, where appropriate. - There is lots of non-endian safe code in here... :/ llvm-svn: 79905
2009-08-24 17:31:37 +08:00
Stream.EmitRecordWithBlob(IDTableAbbrev, Record, IdentifierTable.str());
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
}
// Write the offsets table for identifier IDs.
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
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;
assert(Name.getNameKind() < 0x100 && "Invalid name kind ?");
Emit8(Out, Name.getNameKind());
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
Emit32(Out, Writer.getIdentifierRef(Name.getAsIdentifierInfo()));
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Emit32(Out, Writer.getSelectorRef(Name.getObjCSelector()));
break;
case DeclarationName::CXXOperatorName:
assert(Name.getCXXOverloadedOperator() < 0x100 && "Invalid operator ?");
Emit8(Out, Name.getCXXOverloadedOperator());
break;
case DeclarationName::CXXLiteralOperatorName:
Emit32(Out, Writer.getIdentifierRef(Name.getCXXLiteralIdentifier()));
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;
}
}
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 ?
if (DC->isTranslationUnit() && !Context.getLangOptions().CPlusPlus)
return 0;
// Force the DeclContext to build a its name-lookup table.
Fix an issue with writing to PCH another included PCH, introduced by the "using an AST on-disk hash table for name lookup" commit. When including a PCH and later re-emitting to another PCH, the name lookup tables of DeclContexts may be incomplete, since we now lazily deserialize the visible decls of a particular name. Fix the issue by iterating over the un-deserialized visible decls and completing the lookup tables of DeclContexts before writing them out. llvm-svn: 111698
2010-08-21 07:35:55 +08:00
if (DC->hasExternalVisibleStorage())
DC->MaterializeVisibleDeclsFromExternalStorage();
else
DC->lookup(DeclarationName());
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
// Serialize the contents of the mapping used for lookup. Note that,
// although we have two very different code paths, the serialized
// representation is the same for both cases: a declaration name,
// followed by a size, followed by references to the visible
// declarations that have that name.
uint64_t Offset = Stream.GetCurrentBitNo();
StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
if (!Map || Map->empty())
return 0;
OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
ASTDeclContextNameLookupTrait Trait(*this);
// Create the on-disk hash table representation.
for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
D != DEnd; ++D) {
DeclarationName Name = D->first;
DeclContext::lookup_result Result = D->second.getLookupResult();
Generator.insert(Name, Result, Trait);
}
// Create the on-disk hash table in a buffer.
llvm::SmallString<4096> LookupTable;
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(LookupTable);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}
// Write the lookup table
RecordData Record;
Record.push_back(DECL_CONTEXT_VISIBLE);
Record.push_back(BucketOffset);
Stream.EmitRecordWithBlob(DeclContextVisibleLookupAbbrev, Record,
LookupTable.str());
Stream.EmitRecord(DECL_CONTEXT_VISIBLE, Record);
++NumVisibleDeclContexts;
return Offset;
}
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
/// \brief Write an UPDATE_VISIBLE block for the given context.
///
/// UPDATE_VISIBLE blocks contain the declarations that are added to an existing
/// DeclContext in a dependent AST file. As such, they only exist for the TU
/// (in C++) and for namespaces.
void ASTWriter::WriteDeclContextVisibleUpdate(const DeclContext *DC) {
StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(DC->getLookupPtr());
if (!Map || Map->empty())
return;
OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
ASTDeclContextNameLookupTrait Trait(*this);
// Create the hash table.
for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end();
D != DEnd; ++D) {
DeclarationName Name = D->first;
DeclContext::lookup_result Result = D->second.getLookupResult();
Add testcase for C++ chained PCH and fix the bugs it uncovered in name lookup. llvm-svn: 111882
2010-08-24 08:50:16 +08:00
// For any name that appears in this table, the results are complete, i.e.
// they overwrite results from previous PCHs. Merging is always a mess.
Generator.insert(Name, Result, Trait);
Write visible update blocks. No regressions in normal PCH functionality, but no tests for the chain yet. llvm-svn: 111881
2010-08-24 08:50:09 +08:00
}
// Create the on-disk hash table in a buffer.
llvm::SmallString<4096> LookupTable;
uint32_t BucketOffset;
{
llvm::raw_svector_ostream Out(LookupTable);
// Make sure that no bucket is at offset 0
clang::io::Emit32(Out, 0);
BucketOffset = Generator.Emit(Out, Trait);
}
// Write the lookup table
RecordData Record;
Record.push_back(UPDATE_VISIBLE);
Record.push_back(getDeclID(cast<Decl>(DC)));
Record.push_back(BucketOffset);
Stream.EmitRecordWithBlob(UpdateVisibleAbbrev, Record, LookupTable.str());
}
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) {
if (!SemaRef.Context.getLangOptions().OpenCL)
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);
}
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.
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::WriteAttributes(const AttrVec &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());
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){
const Attr * A = *i;
Record.push_back(A->getKind()); // FIXME: stable encoding, target attrs
AddSourceLocation(A->getLocation(), Record);
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)
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
: Stream(Stream), Context(0), Chain(0), SerializationListener(0),
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),
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
FirstIdentID(NUM_PREDEF_IDENT_IDS), NextIdentID(FirstIdentID),
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 the local -> global remapping for macro definition IDs in the detailed preprocessing record. Tested with the standard "gaps" method. llvm-svn: 136882
2011-08-05 00:36:56 +08:00
FirstMacroID(NUM_PREDEF_MACRO_IDS), NextMacroID(FirstMacroID),
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
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls,
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,
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) {
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;
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
WriteASTCore(SemaRef, StatCalls, isysroot, OutputFile);
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;
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);
}
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
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,
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) {
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;
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;
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,
Context.getLangOptions().NoBuiltin);
for (unsigned I = 0, N = BuiltinNames.size(); I != N; ++I)
getIdentifierRef(&Table.get(BuiltinNames[I]));
}
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// Build a record containing all of the tentative definitions in this file, in
Add VarDecl::isThisDeclarationADefinition(), which properly encapsulates the logic for when a variable declaration is a (possibly tentativ) definition. Add a few functions building on this, and shift C tentative definition handling over to this new functionality. This shift also kills the Sema::TentativeDefinitions map and instead simply stores all declarations in the renamed list. The correct handling for multiple tentative definitions is instead shifted to the final walk of the list. llvm-svn: 94968
2010-02-01 06:27:38 +08:00
// TentativeDefinitions order. Generally, this record will be empty for
Fix PR4922, where Sema would complete tentative definitions in nondeterminstic order because it was doing so while iterating over a densemap. There are still similar problems in other places, for example WeakUndeclaredIdentifiers is still written to the PCH file in a nondeterminstic order, and we emit warnings about #pragma weak in nondeterminstic order. llvm-svn: 81236
2009-09-09 02:19:27 +08:00
// headers.
Support tentative definitions in precompiled headers. This isn't likely to happen (ever), but at least we'll do the right thing when it does. llvm-svn: 69829
2009-04-23 06:02:47 +08:00
RecordData TentativeDefinitions;
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) {
if (TD->second->getPCHLevel() == 0)
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);
}
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);
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
WriteMetadata(Context, isysroot, OutputFile);
Split the normal and chained PCH writing paths and add a tiny bit of implementation to the latter. WIP. llvm-svn: 108200
2010-07-13 06:02:52 +08:00
WriteLanguageOptions(Context.getLangOptions());
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 (StatCalls && isysroot.empty())
Fix a documentation paste-o and eliminate a useless function parameter, both found by Sebastian llvm-svn: 108214
2010-07-13 07:48:14 +08:00
WriteStatCache(*StatCalls);
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot);
Move the serialization of the MODULE_OFFSET_MAP out of the source-manager-writing code and into the general chained-PCH writing code llvm-svn: 136624
2011-08-02 00:54:33 +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
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
// 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);
llvm::SmallString<2048> Buffer;
{
llvm::raw_svector_ostream Out(Buffer);
for (ModuleManager::ModuleConstIterator M = Chain->ModuleMgr.begin(),
MEnd = Chain->ModuleMgr.end();
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);
io::Emit32(Out, (*M)->BasePreprocessedEntityID);
io::Emit32(Out, (*M)->BaseMacroDefinitionID);
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());
}
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) {
if ((*I)->getPCHLevel() == 0)
NewGlobalDecls.push_back(std::make_pair((*I)->getKind(), GetDeclRef(*I)));
else if ((*I)->isChangedSinceDeserialization())
(void)GetDeclRef(*I); // Make sure it's written, but don't record it.
}
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);
AddDeclRef(NS, Record);
}
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
}
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.getBuiltinVaListType(), SpecialTypes);
AddTypeRef(Context.ObjCProtoType, 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);
SpecialTypes.push_back(Context.isInt128Installed());
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
Write the preprocessor block after we write out types + declarations, so that we catch any macros used within the declarations and types. Also, properly store a NULL selector. llvm-svn: 84334
2009-10-18 01:25:45 +08:00
WritePreprocessor(PP);
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);
Lazy deserialization of macro definitions for precompiled headers. This optimization improves performance on the Carbon-prefixed "Hello, World!" example by 57%. For reference, we're now about 2.25x faster than GCC PCH. We're also pulling in far less of the PCH file: *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69755
2009-04-22 07:56:24 +08:00
WriteIdentifierTable(PP);
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 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);
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
/// Build a record containing first declarations from a chained PCH and the
Do the PCH->AST rename for ASTWriter's implementation parts. llvm-svn: 111464
2010-08-19 07:56:27 +08:00
/// most recent declarations in this AST that they point to.
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
RecordData FirstLatestDeclIDs;
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 (FirstLatestDeclMap::iterator I = FirstLatestDecls.begin(),
E = FirstLatestDecls.end();
I != E; ++I) {
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
assert(I->first->getPCHLevel() > I->second->getPCHLevel() &&
"Expected first & second to be in different PCHs");
AddDeclRef(I->first, FirstLatestDeclIDs);
AddDeclRef(I->second, FirstLatestDeclIDs);
}
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
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
if (!FirstLatestDeclIDs.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(REDECLS_UPDATE_LATEST, FirstLatestDeclIDs);
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Write the record containing external, unnamed definitions.
if (!ExternalDefinitions.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(EXTERNAL_DEFINITIONS, ExternalDefinitions);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Write the record containing tentative definitions.
if (!TentativeDefinitions.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(TENTATIVE_DEFINITIONS, TentativeDefinitions);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Change Sema's UnusedStaticFuncs to UnusedFileScopedDecls to allow also keeping track of unused file scoped variables. This is only preparation, currently only static function definitions are tracked, as before. llvm-svn: 111025
2010-08-14 02:42:17 +08:00
// Write the record containing unused file scoped decls.
if (!UnusedFileScopedDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(UNUSED_FILESCOPED_DECLS, UnusedFileScopedDecls);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing weak undeclared identifiers.
if (!WeakUndeclaredIdentifiers.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(WEAK_UNDECLARED_IDENTIFIERS,
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
WeakUndeclaredIdentifiers);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
// Write the record containing locally-scoped external definitions.
if (!LocallyScopedExternalDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(LOCALLY_SCOPED_EXTERNAL_DECLS,
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
LocallyScopedExternalDecls);
// Write the record containing ext_vector type names.
if (!ExtVectorDecls.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
Record macros in dependent PCHs. Also add various info tables to dependent PCHs; tests for this to follow. llvm-svn: 109554
2010-07-28 07:01:28 +08:00
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing VTable uses information.
if (!VTableUses.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(VTABLE_USES, VTableUses);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing dynamic classes declarations.
if (!DynamicClasses.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(DYNAMIC_CLASSES, DynamicClasses);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing pending implicit instantiations.
Rename *PendingImplicitInstantiations to *PendingInstantiations. No functionality changed. llvm-svn: 112040
2010-08-25 16:44:16 +08:00
if (!PendingInstantiations.empty())
Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Write the record containing declaration references of Sema.
if (!SemaDeclRefs.empty())
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);
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);
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();
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
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();
}
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;
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
if (DeclsToRewrite.count(D))
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;
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<std::pair<DeclID, uint64_t>, 16>::iterator
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
I = ReplacedDecls.begin(), E = ReplacedDecls.end(); I != E; ++I) {
Record.push_back(I->first);
Record.push_back(I->second);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Stream.EmitRecord(DECL_REPLACEMENTS, Record);
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
}
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));
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
if (II == 0)
return 0;
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
IdentID &ID = IdentifierIDs[II];
Store unique IDs for identifiers in the PCH file. Use some bitmangling so that we only need to perform the lookup and identifier resolution once per identifier in the PCH file. llvm-svn: 68846
2009-04-11 08:14:32 +08:00
if (ID == 0)
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
ID = NextIdentID++;
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
return ID;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Macro definitions in AST files have their own IDs. llvm-svn: 114014
2010-09-16 03:54:06 +08:00
MacroID ASTWriter::getMacroDefinitionID(MacroDefinition *MD) {
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
if (MD == 0)
return 0;
Macro definitions in AST files have their own IDs. llvm-svn: 114014
2010-09-16 03:54:06 +08:00
MacroID &ID = MacroDefinitions[MD];
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
if (ID == 0)
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
ID = NextMacroID++;
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
return ID;
}
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:
case TemplateArgument::Pack:
break;
}
}
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
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) {
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) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
if (D == 0) {
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
return 0;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Fix a marvelous chained AST writing bug, where we end up with the following amusing sequence: - AST writing schedules writing a type X* that it had never seen before - AST writing starts writing another declaration, ends up deserializing X* from a prior AST file. Now we have two type IDs for the same type! - AST writer tries to write X*. It only has the lower-numbered ID from the the prior AST file, so references to the higher-numbered ID that was scheduled for writing go off into lalaland. To fix this, keep the higher-numbered ID so we end up writing the type twice. Since this issue occurs so rarely, and type records are generally rather small, I deemed this better than the alternative: to keep a separate mapping from the higher-numbered IDs to the lower-numbered IDs, which we would end up having to check whenever we want to deserialize any type. Fixes <rdar://problem/8511624>, I think. llvm-svn: 115647
2010-10-06 02:37:06 +08:00
assert(!(reinterpret_cast<uintptr_t>(D) & 0x01) && "Invalid decl pointer");
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DeclID &ID = DeclIDs[D];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (ID == 0) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// We haven't seen this declaration before. Give it a new ID and
// enqueue it in the list of declarations to emit.
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
ID = NextDeclID++;
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
DeclTypesToEmit.push(const_cast<Decl *>(D));
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
} else if (ID < FirstDeclID && D->isChangedSinceDeserialization()) {
// We don't add it to the replacement collection here, because we don't
// have the offset yet.
DeclTypesToEmit.push(const_cast<Decl *>(D));
// Reset the flag, so that we don't add this decl multiple times.
const_cast<Decl *>(D)->setChangedSinceDeserialization(false);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
return ID;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DeclID ASTWriter::getDeclID(const Decl *D) {
Write the identifier table into the PCH file as an on-disk hash table that also includes the contents of the IdentifierInfo itself (the various fields and flags, along with the chain of identifiers visible at the top level that have that name). We don't make any use of the hash table yet, except that our identifier ID -> string mapping points into the hash table now. llvm-svn: 69625
2009-04-21 04:36:09 +08:00
if (D == 0)
return 0;
assert(DeclIDs.find(D) != DeclIDs.end() && "Declaration not emitted!");
return DeclIDs[D];
}
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);
break;
case TemplateArgument::Integral:
AddAPSInt(*Arg.getAsIntegral(), Record);
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);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
AddTypeSourceInfo(Init->getBaseClassInfo(), Record);
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);
AddDeclRef(Init->getTargetConstructor(), Record);
} 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;
Record.push_back(Data.UserDeclaredConstructor);
Record.push_back(Data.UserDeclaredCopyConstructor);
Record.push_back(Data.UserDeclaredCopyAssignment);
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);
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);
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);
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);
Record.push_back(Data.DeclaredCopyAssignment);
Record.push_back(Data.DeclaredDestructor);
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);
}
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");
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
assert(!Chain && "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 &&
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
FirstSelectorID == NextSelectorID &&
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
FirstMacroID == NextMacroID &&
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
"Setting chain after writing has started.");
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
FirstDeclID += Chain->getTotalNumDecls();
FirstTypeID += Chain->getTotalNumTypes();
FirstIdentID += Chain->getTotalNumIdentifiers();
FirstSelectorID += Chain->getTotalNumSelectors();
FirstMacroID += Chain->getTotalNumMacroDefinitions();
NextDeclID = FirstDeclID;
NextTypeID = FirstTypeID;
NextIdentID = FirstIdentID;
NextSelectorID = FirstSelectorID;
NextMacroID = FirstMacroID;
Make macro weirdness in chained PCH work. This required changing the way PCHReader and PCHWriter are initialized to correctly pick up all initializer. On the upside, this means that there is far less repetition in the dependent PCH now. llvm-svn: 109823
2010-07-30 08:29:29 +08:00
}
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;
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
if (II->hasMacroDefinition())
DeserializedMacroNames.push_back(II);
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
}
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::DeclRead(DeclID ID, const Decl *D) {
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
DeclIDs[D] = ID;
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
}
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
void ASTWriter::SelectorRead(SelectorID ID, Selector S) {
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
SelectorIDs[S] = ID;
}
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
void ASTWriter::MacroDefinitionRead(serialization::MacroID 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) {
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
void ASTWriter::CompletedTagDefinition(const TagDecl *D) {
assert(D->isDefinition());
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
// We are interested when a PCH decl is modified.
if (RD->getPCHLevel() > 0) {
// 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
}
for (CXXRecordDecl::redecl_iterator
I = RD->redecls_begin(), E = RD->redecls_end(); I != E; ++I) {
CXXRecordDecl *Redecl = cast<CXXRecordDecl>(*I);
if (Redecl == RD)
continue;
// We are interested when a PCH decl is modified.
if (Redecl->getPCHLevel() > 0) {
UpdateRecord &Record = DeclUpdates[Redecl];
Record.push_back(UPD_CXX_SET_DEFINITIONDATA);
assert(Redecl->DefinitionData);
assert(Redecl->DefinitionData->Definition == D);
AddDeclRef(D, Record); // the DefinitionDecl
}
}
}
}
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) {
// TU and namespaces are handled elsewhere.
if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC))
return;
if (!(D->getPCHLevel() == 0 && cast<Decl>(DC)->getPCHLevel() > 0))
return; // Not a source decl added to a DeclContext from PCH.
AddUpdatedDeclContext(DC);
}
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) {
assert(D->isImplicit());
if (!(D->getPCHLevel() == 0 && RD->getPCHLevel() > 0))
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.
assert(RD->isDefinition());
UpdateRecord &Record = DeclUpdates[RD];
Record.push_back(UPD_CXX_ADDED_IMPLICIT_MEMBER);
AddDeclRef(D, Record);
}
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.
TD = TD->getCanonicalDecl();
Use the ASTMutationListener to track added template specializations in a chained PCH. llvm-svn: 117533
2010-10-28 15:38:42 +08:00
if (!(D->getPCHLevel() == 0 && TD->getPCHLevel() > 0))
return; // Not a source specialization added to a template from PCH.
UpdateRecord &Record = DeclUpdates[TD];
Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
AddDeclRef(D, Record);
}
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.
TD = TD->getCanonicalDecl();
if (!(D->getPCHLevel() == 0 && TD->getPCHLevel() > 0))
return; // Not a source specialization added to a template from PCH.
UpdateRecord &Record = DeclUpdates[TD];
Record.push_back(UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION);
AddDeclRef(D, Record);
}
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) {
if (D->getPCHLevel() == 0)
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) {
if (D->getPCHLevel() == 0)
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);
}
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
ASTSerializationListener::~ASTSerializationListener() { }