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/ASTReader.cpp

5525 lines
194 KiB
C++
Raw Normal View History

Rename the ASTReader implementation files. llvm-svn: 111473
2010-08-19 07:57:11 +08:00
//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===//
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// This file defines the ASTReader class, which reads 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
//
//===----------------------------------------------------------------------===//
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
Rename the ASTReader header files. llvm-svn: 111474
2010-08-19 07:57:17 +08:00
#include "clang/Serialization/ASTReader.h"
#include "clang/Serialization/ASTDeserializationListener.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"
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
#include "clang/Frontend/FrontendDiagnostic.h"
Tweak PCH -include handling to make sure it matches the name as would be present in the predefines buffer. llvm-svn: 86903
2009-11-12 07:58:53 +08:00
#include "clang/Frontend/Utils.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"
More header elimination. The goal of all this is to allow Parser to #include Sema.h while keeping all the AST declarations opaque. That may not be reasonably attainable, though. llvm-svn: 111907
2010-08-24 16:50:51 +08:00
#include "clang/Sema/Scope.h"
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
#include "clang/AST/ASTConsumer.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"
Move more stuff out of Sema.h. llvm-svn: 112026
2010-08-25 13:32:35 +08:00
#include "clang/AST/DeclTemplate.h"
PCH support for a few very, very simple kinds of expressions. Hook up expression (de-)serialization for VLAs, variable initializers, enum constant initializers, and bitfield widths. llvm-svn: 69075
2009-04-15 05:18:50 +08:00
#include "clang/AST/Expr.h"
Remove a header dependency from Sema.h at the cost of some type safety. If someone wants to fix this some other way.... llvm-svn: 111905
2010-08-24 15:32:53 +08:00
#include "clang/AST/ExprCXX.h"
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
#include "clang/AST/NestedNameSpecifier.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"
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
#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"
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/Lex/Preprocessor.h"
Add PCH support for #import. llvm-svn: 69987
2009-04-25 04:03:17 +08:00
#include "clang/Lex/HeaderSearch.h"
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
#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"
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"
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"
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
#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"
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/BitstreamReader.h"
#include "llvm/Support/MemoryBuffer.h"
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
#include "llvm/Support/ErrorHandling.h"
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 "llvm/Support/FileSystem.h"
Merge System into Support. llvm-svn: 120297
2010-11-30 02:12:39 +08:00
#include "llvm/Support/Path.h"
Use error_code instead of std::string* for MemoryBuffer. llvm-svn: 121378
2010-12-10 01:36:38 +08:00
#include "llvm/Support/system_error.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 <algorithm>
Allow some differences between the predefines buffer used to build a PCH file and the predefines buffer used when including the PCH file. We (explicitly) detect conflicting macro definitions (rejecting the PCH file) and about missing macro definitions (they'll be automatically pulled from the PCH file anyway). We're missing some checking to make sure that new macro definitions won't have any impact on the PCH file itself (e.g., #define'ing an identifier that the PCH file used). llvm-svn: 70316
2009-04-29 02:58:38 +08:00
#include <iterator>
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 <cstdio>
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
#include <sys/stat.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 <iostream>
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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
//===----------------------------------------------------------------------===//
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// PCH validator implementation
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
//===----------------------------------------------------------------------===//
Rename various classes from PCH to AST. llvm-svn: 111471
2010-08-19 07:56:56 +08:00
ASTReaderListener::~ASTReaderListener() {}
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
bool
PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
const LangOptions &PPLangOpts = PP.getLangOptions();
#define PARSE_LANGOPT_BENIGN(Option)
#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \
if (PPLangOpts.Option != LangOpts.Option) { \
Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \
return true; \
}
PARSE_LANGOPT_BENIGN(Trigraphs);
PARSE_LANGOPT_BENIGN(BCPLComment);
PARSE_LANGOPT_BENIGN(DollarIdents);
PARSE_LANGOPT_BENIGN(AsmPreprocessor);
PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions);
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
PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_BENIGN(ImplicitInt);
PARSE_LANGOPT_BENIGN(Digraphs);
PARSE_LANGOPT_BENIGN(HexFloats);
PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99);
C1X: add a language standard llvm-svn: 129553
2011-04-15 08:35:23 +08:00
PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_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
PARSE_LANGOPT_BENIGN(MSCVersion);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
PARSE_LANGOPT_BENIGN(CXXOperatorName);
PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c);
PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2);
PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi);
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
PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2);
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
PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext);
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
PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties,
diag::warn_pch_objc_auto_properties);
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
PARSE_LANGOPT_BENIGN(ObjCInferRelatedResultType)
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings,
Check for -fno-constant-cfstrings consistency in pch. llvm-svn: 102130
2010-04-23 05:01:59 +08:00
diag::warn_pch_no_constant_cfstrings);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_BENIGN(PascalStrings);
PARSE_LANGOPT_BENIGN(WritableStrings);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PARSE_LANGOPT_IMPORTANT(LaxVectorConversions,
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
diag::warn_pch_lax_vector_conversions);
PCH support for OpenCL language options llvm-svn: 74220
2009-06-26 06:57:40 +08:00
PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions);
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
PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions);
Add a CXXExceptions flag to LangOptions. llvm-svn: 126299
2011-02-23 11:04:54 +08:00
PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions);
PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions);
Basic support for -mms-bitfields, from Carl Norum! llvm-svn: 124661
2011-02-01 23:15:22 +08:00
PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime);
PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding);
PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics,
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
diag::warn_pch_thread_safe_statics);
Add basic support for -pthread. - Patch by David Chisnall, with PCH and Darwin support mixed in. llvm-svn: 80883
2009-09-03 12:54:28 +08:00
PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks);
PARSE_LANGOPT_BENIGN(EmitAllDecls);
PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno);
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
PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior());
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PARSE_LANGOPT_IMPORTANT(HeinousExtensions,
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
diag::warn_pch_heinous_extensions);
// FIXME: Most of the options below are benign if the macro wasn't
// used. Unfortunately, this means that a PCH compiled without
// optimization can't be used with optimization turned on, even
// though the only thing that changes is whether __OPTIMIZE__ was
// defined... but if __OPTIMIZE__ never showed up in the header, it
// doesn't matter. We could consider making this some special kind
// of check.
PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize);
PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size);
PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static);
PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level);
PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline);
PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline);
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
PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control);
PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed);
Adding -fshort-wchar option. llvm-svn: 86167
2009-11-06 04:14:16 +08:00
PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar);
Implement -fshort-enums (rdar://8490496). llvm-svn: 116020
2010-10-08 08:25:19 +08:00
PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Reader.Diag(diag::warn_pch_gc_mode)
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
<< LangOpts.getGCMode() << PPLangOpts.getGCMode();
return true;
}
PARSE_LANGOPT_BENIGN(getVisibilityMode());
Add missing PCH support for -fstack-protector. llvm-svn: 82435
2009-09-21 12:16:19 +08:00
PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(),
diag::warn_pch_stack_protector);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT_BENIGN(InstantiationDepth);
PCH support for OpenCL language options llvm-svn: 74220
2009-06-26 06:57:40 +08:00
PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl);
Serialization: support for CUDA language extensions llvm-svn: 120588
2010-12-02 03:14:57 +08:00
PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_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
PARSE_LANGOPT_BENIGN(CatchUndefined);
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
PARSE_LANGOPT_BENIGN(DefaultFPContract);
Add missing PCH support for -fstack-protector. llvm-svn: 82435
2009-09-21 12:16:19 +08:00
PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors);
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
PARSE_LANGOPT_BENIGN(SpellChecking);
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
PARSE_LANGOPT_IMPORTANT(ObjCAutoRefCount, diag::warn_pch_auto_ref_count);
PARSE_LANGOPT_BENIGN(ObjCInferRelatedReturnType);
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
#undef PARSE_LANGOPT_IMPORTANT
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
#undef PARSE_LANGOPT_BENIGN
return false;
}
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
bool PCHValidator::ReadTargetTriple(StringRef Triple) {
StringRefify some PCH interfaces. llvm-svn: 86775
2009-11-11 08:52:11 +08:00
if (Triple == PP.getTargetInfo().getTriple().str())
return false;
Reader.Diag(diag::warn_pch_target_triple)
<< Triple << PP.getTargetInfo().getTriple().str();
return true;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
}
Hide a bunch of symbols. llvm-svn: 120153
2010-11-26 02:29:30 +08:00
namespace {
struct EmptyStringRef {
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
bool operator ()(StringRef r) const { return r.empty(); }
Hide a bunch of symbols. llvm-svn: 120153
2010-11-26 02:29:30 +08:00
};
struct EmptyBlock {
bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
};
}
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +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
static bool EqualConcatenations(SmallVector<StringRef, 2> L,
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
PCHPredefinesBlocks R) {
// First, sum up the lengths.
unsigned LL = 0, RL = 0;
for (unsigned I = 0, N = L.size(); I != N; ++I) {
LL += L[I].size();
}
for (unsigned I = 0, N = R.size(); I != N; ++I) {
RL += R[I].Data.size();
}
if (LL != RL)
return false;
if (LL == 0 && RL == 0)
return true;
// Kick out empty parts, they confuse the algorithm below.
L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
// Do it the hard way. At this point, both vectors must be non-empty.
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 LR = L[0], RR = R[0].Data;
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
Suppress !+Asserts warning. llvm-svn: 108480
2010-07-16 08:00:11 +08:00
(void) RN;
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
for (;;) {
// Compare the current pieces.
if (LR.size() == RR.size()) {
// If they're the same length, it's pretty easy.
if (LR != RR)
return false;
// Both pieces are done, advance.
++LI;
++RI;
// If either string is done, they're both done, since they're the same
// length.
if (LI == LN) {
assert(RI == RN && "Strings not the same length after all?");
return true;
}
LR = L[LI];
RR = R[RI].Data;
} else if (LR.size() < RR.size()) {
// Right piece is longer.
if (!RR.startswith(LR))
return false;
++LI;
assert(LI != LN && "Strings not the same length after all?");
RR = RR.substr(LR.size());
LR = L[LI];
} else {
// Left piece is longer.
if (!LR.startswith(RR))
return false;
++RI;
assert(RI != RN && "Strings not the same length after all?");
LR = LR.substr(RR.size());
RR = R[RI].Data;
}
}
}
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 std::pair<FileID, StringRef::size_type>
FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) {
std::pair<FileID, StringRef::size_type> Res;
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
Res.second = Buffers[I].Data.find(MacroDef);
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
if (Res.second != StringRef::npos) {
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
Res.first = Buffers[I].BufferID;
break;
}
}
return Res;
}
bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
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 OriginalFileName,
Preserve what the user passed to -include when emitting .d files. Fixes PR8974! llvm-svn: 126334
2011-02-24 05:16:44 +08:00
std::string &SuggestedPredefines,
FileManager &FileMgr) {
Tweak PCH -include handling to make sure it matches the name as would be present in the predefines buffer. llvm-svn: 86903
2009-11-12 07:58:53 +08:00
// We are in the context of an implicit include, so the predefines buffer will
// have a #include entry for the PCH file itself (as normalized by the
// preprocessor initialization). Find it and skip over it in the checking
// below.
Redo how PCH handles its implicit include. Instead of treating this specially in the front-end (as far as the preprocessor goes), follow the usual logic of inserting the (original include path) name into the predefines buffer. This pushes the responsibility for handling this to PCH instead of the front-end. In PCH this requires being a little more clever when we diff the predefines buffers. Neither of these solutions are particularly great, I think what we eventually should do is something like gcc where we insert a special marker to indicate the PCH file, but then run the preprocessor as usual. This would be clearer and would allow us to drop the overly clever predefines handling. llvm-svn: 86806
2009-11-11 13:29:04 +08:00
llvm::SmallString<256> PCHInclude;
PCHInclude += "#include \"";
Preserve what the user passed to -include when emitting .d files. Fixes PR8974! llvm-svn: 126334
2011-02-24 05:16:44 +08:00
PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr);
Redo how PCH handles its implicit include. Instead of treating this specially in the front-end (as far as the preprocessor goes), follow the usual logic of inserting the (original include path) name into the predefines buffer. This pushes the responsibility for handling this to PCH instead of the front-end. In PCH this requires being a little more clever when we diff the predefines buffers. Neither of these solutions are particularly great, I think what we eventually should do is something like gcc where we insert a special marker to indicate the PCH file, but then run the preprocessor as usual. This would be clearer and would allow us to drop the overly clever predefines handling. llvm-svn: 86806
2009-11-11 13:29:04 +08:00
PCHInclude += "\"\n";
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
std::pair<StringRef,StringRef> Split =
StringRef(PP.getPredefines()).split(PCHInclude.str());
StringRef Left = Split.first, Right = Split.second;
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Left == PP.getPredefines()) {
Error("Missing PCH include entry!");
return true;
}
Redo how PCH handles its implicit include. Instead of treating this specially in the front-end (as far as the preprocessor goes), follow the usual logic of inserting the (original include path) name into the predefines buffer. This pushes the responsibility for handling this to PCH instead of the front-end. In PCH this requires being a little more clever when we diff the predefines buffers. Neither of these solutions are particularly great, I think what we eventually should do is something like gcc where we insert a special marker to indicate the PCH file, but then run the preprocessor as usual. This would be clearer and would allow us to drop the overly clever predefines handling. llvm-svn: 86806
2009-11-11 13:29:04 +08:00
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
// If the concatenation of all the PCH buffers is equal to the adjusted
// command line, we're done.
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<StringRef, 2> CommandLine;
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
CommandLine.push_back(Left);
CommandLine.push_back(Right);
if (EqualConcatenations(CommandLine, Buffers))
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
return false;
SourceManager &SourceMgr = PP.getSourceManager();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rewrite splitLines using StringRef; this is much simpler, and also now avoids tons of std::string trashing. I plan to move this and other fun string munging utilities to a StringRefExtras.h at some point if no one beats me to it. On a synthetic benchmark on x86_64, llvm-gcc actually generates code thats 10% faster using the StringRef version. gcc miscompiles the synthetic benchmark, which I'm crossing my fingers and hoping won't happen here. clang compiles the sythetic benchmark correctly (wootness), but the StringRef version is slower. Silly clang. llvm-svn: 86799
2009-11-11 11:45:59 +08:00
// The predefines buffers are different. Determine what the differences are,
// and whether they require us to reject the PCH file.
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<StringRef, 8> PCHLines;
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Remove local splitLines reimplementation. llvm-svn: 88661
2009-11-14 00:46:11 +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
SmallVector<StringRef, 8> CmdLineLines;
Remove local splitLines reimplementation. llvm-svn: 88661
2009-11-14 00:46:11 +08:00
Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Support implicit includes when generating a PCH and allow the user to pass a -include on the command line following the PCH include. Fixes rdar://7382084. llvm-svn: 115159
2010-10-01 00:53:50 +08:00
// Pick out implicit #includes after the PCH and don't consider them for
// validation; we will insert them into SuggestedPredefines so that the
// preprocessor includes them.
std::string IncludesAfterPCH;
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<StringRef, 8> AfterPCHLines;
Support implicit includes when generating a PCH and allow the user to pass a -include on the command line following the PCH include. Fixes rdar://7382084. llvm-svn: 115159
2010-10-01 00:53:50 +08:00
Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
if (AfterPCHLines[i].startswith("#include ")) {
IncludesAfterPCH += AfterPCHLines[i];
IncludesAfterPCH += '\n';
} else {
CmdLineLines.push_back(AfterPCHLines[i]);
}
}
// Make sure we add the includes last into SuggestedPredefines before we
// exit this function.
struct AddIncludesRAII {
std::string &SuggestedPredefines;
std::string &IncludesAfterPCH;
AddIncludesRAII(std::string &SuggestedPredefines,
std::string &IncludesAfterPCH)
: SuggestedPredefines(SuggestedPredefines),
IncludesAfterPCH(IncludesAfterPCH) { }
~AddIncludesRAII() {
SuggestedPredefines += IncludesAfterPCH;
}
} AddIncludes(SuggestedPredefines, IncludesAfterPCH);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
// Sort both sets of predefined buffer lines, since we allow some extra
// definitions and they may appear at any point in the output.
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
std::sort(CmdLineLines.begin(), CmdLineLines.end());
std::sort(PCHLines.begin(), PCHLines.end());
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
// Determine which predefines that were used to build the PCH file are missing
// from the command line.
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
std::vector<StringRef> MissingPredefines;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
std::set_difference(PCHLines.begin(), PCHLines.end(),
CmdLineLines.begin(), CmdLineLines.end(),
std::back_inserter(MissingPredefines));
bool MissingDefines = false;
bool ConflictingDefines = false;
for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
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 Missing = MissingPredefines[I];
Support implicit includes when generating a PCH and allow the user to pass a -include on the command line following the PCH include. Fixes rdar://7382084. llvm-svn: 115159
2010-10-01 00:53:50 +08:00
if (Missing.startswith("#include ")) {
// An -include was specified when generating the PCH; it is included in
// the PCH, just ignore it.
continue;
}
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
if (!Missing.startswith("#define ")) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Reader.Diag(diag::warn_pch_compiler_options_mismatch);
return true;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rewrite splitLines using StringRef; this is much simpler, and also now avoids tons of std::string trashing. I plan to move this and other fun string munging utilities to a StringRefExtras.h at some point if no one beats me to it. On a synthetic benchmark on x86_64, llvm-gcc actually generates code thats 10% faster using the StringRef version. gcc miscompiles the synthetic benchmark, which I'm crossing my fingers and hoping won't happen here. clang compiles the sythetic benchmark correctly (wootness), but the StringRef version is slower. Silly clang. llvm-svn: 86799
2009-11-11 11:45:59 +08:00
// This is a macro definition. Determine the name of the macro we're
// defining.
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
std::string::size_type StartOfMacroName = strlen("#define ");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::string::size_type EndOfMacroName
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
= Missing.find_first_of("( \n\r", StartOfMacroName);
assert(EndOfMacroName != std::string::npos &&
"Couldn't find the end of the macro name");
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 MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Rewrite splitLines using StringRef; this is much simpler, and also now avoids tons of std::string trashing. I plan to move this and other fun string munging utilities to a StringRefExtras.h at some point if no one beats me to it. On a synthetic benchmark on x86_64, llvm-gcc actually generates code thats 10% faster using the StringRef version. gcc miscompiles the synthetic benchmark, which I'm crossing my fingers and hoping won't happen here. clang compiles the sythetic benchmark correctly (wootness), but the StringRef version is slower. Silly clang. llvm-svn: 86799
2009-11-11 11:45:59 +08:00
// Determine whether this macro was given a different definition on the
// command line.
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
std::string MacroDefStart = "#define " + MacroName.str();
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
std::string::size_type MacroDefLen = MacroDefStart.size();
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<StringRef, 8>::iterator ConflictPos
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
= std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
MacroDefStart);
for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
Rewrite splitLines using StringRef; this is much simpler, and also now avoids tons of std::string trashing. I plan to move this and other fun string munging utilities to a StringRefExtras.h at some point if no one beats me to it. On a synthetic benchmark on x86_64, llvm-gcc actually generates code thats 10% faster using the StringRef version. gcc miscompiles the synthetic benchmark, which I'm crossing my fingers and hoping won't happen here. clang compiles the sythetic benchmark correctly (wootness), but the StringRef version is slower. Silly clang. llvm-svn: 86799
2009-11-11 11:45:59 +08:00
if (!ConflictPos->startswith(MacroDefStart)) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// Different macro; we're done.
ConflictPos = CmdLineLines.end();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
break;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(ConflictPos->size() > MacroDefLen &&
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
"Invalid #define in predefines buffer?");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if ((*ConflictPos)[MacroDefLen] != ' ' &&
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
(*ConflictPos)[MacroDefLen] != '(')
continue; // Longer macro name; keep trying.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// We found a conflicting macro definition.
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (ConflictPos != CmdLineLines.end()) {
Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
<< MacroName;
// Show the definition of this macro within the PCH file.
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
std::pair<FileID, StringRef::size_type> MacroLoc =
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
FindMacro(Buffers, Missing);
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
assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
SourceLocation PCHMissingLoc =
SourceMgr.getLocForStartOfFile(MacroLoc.first)
.getFileLocWithOffset(MacroLoc.second);
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
ConflictingDefines = true;
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rewrite splitLines using StringRef; this is much simpler, and also now avoids tons of std::string trashing. I plan to move this and other fun string munging utilities to a StringRefExtras.h at some point if no one beats me to it. On a synthetic benchmark on x86_64, llvm-gcc actually generates code thats 10% faster using the StringRef version. gcc miscompiles the synthetic benchmark, which I'm crossing my fingers and hoping won't happen here. clang compiles the sythetic benchmark correctly (wootness), but the StringRef version is slower. Silly clang. llvm-svn: 86799
2009-11-11 11:45:59 +08:00
// If the macro doesn't conflict, then we'll just pick up the macro
// definition from the PCH file. Warn the user that they made a mistake.
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (ConflictingDefines)
continue; // Don't complain if there are already conflicting defs
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (!MissingDefines) {
Reader.Diag(diag::warn_cmdline_missing_macro_defs);
MissingDefines = true;
}
// Show the definition of this macro within the PCH file.
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
std::pair<FileID, StringRef::size_type> MacroLoc =
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
FindMacro(Buffers, Missing);
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
assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
SourceLocation PCHMissingLoc =
SourceMgr.getLocForStartOfFile(MacroLoc.first)
.getFileLocWithOffset(MacroLoc.second);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (ConflictingDefines)
return true;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// Determine what predefines were introduced based on command-line
// parameters that were not present when building the PCH
// file. Extra #defines are okay, so long as the identifiers being
// defined were not used within the precompiled header.
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
std::vector<StringRef> ExtraPredefines;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
PCHLines.begin(), PCHLines.end(),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::back_inserter(ExtraPredefines));
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
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 &Extra = ExtraPredefines[I];
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
if (!Extra.startswith("#define ")) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Reader.Diag(diag::warn_pch_compiler_options_mismatch);
return true;
}
// This is an extra macro definition. Determine the name of the
// macro we're defining.
std::string::size_type StartOfMacroName = strlen("#define ");
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::string::size_type EndOfMacroName
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
= Extra.find_first_of("( \n\r", StartOfMacroName);
assert(EndOfMacroName != std::string::npos &&
"Couldn't find the end of the macro name");
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 MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// Check whether this name was used somewhere in the PCH file. If
// so, defining it as a macro could change behavior, so we reject
// the PCH file.
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
if (IdentifierInfo *II = Reader.get(MacroName)) {
Replace startsWith functions with StringRef. llvm-svn: 86774
2009-11-11 08:52:00 +08:00
Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
return true;
}
// Add this definition to the suggested predefines buffer.
SuggestedPredefines += Extra;
SuggestedPredefines += '\n';
}
// If we get here, it's because the predefines buffer had compatible
// contents. Accept the PCH file.
return false;
}
Fix header-search problems with precompiled headers, where the presence or absence of header map arguments when using the precompiled header would cause Clang to get confused about which headers had already been included/imported, along with their controlling macros. The fundamental problem is that the serialization of the header search information was relying on the UIDs of FileEntry objects at PCH generation time and PCH load time to be equivalent, which effectively means that we had to probe the same files in the same order. Differing header map arguments caused an extra FileEntry lookup, but it's easy to imagine other minor command-line arguments triggering this problem. Header-search information is now encoded along with the source-location entry for a file, so that we register information about a file's properties as a header at the same time we create the FileEntry for that file. Fixes <rdar://problem/7743243>. llvm-svn: 98636
2010-03-17 00:35:32 +08:00
void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
unsigned ID) {
PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
++NumHeaderInfos;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
}
void PCHValidator::ReadCounter(unsigned Value) {
PP.setCounterValue(Value);
}
add three new objc expression types. @selector doesn't work because we have no way to serialize selectors yet. llvm-svn: 69780
2009-04-22 14:29:42 +08:00
//===----------------------------------------------------------------------===//
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// AST reader implementation
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
//===----------------------------------------------------------------------===//
Add PCH read/write support for ObjC statements. llvm-svn: 70143
2009-04-27 02:52:16 +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
void
Rename various classes from PCH to AST. llvm-svn: 111471
2010-08-19 07:56:56 +08:00
ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
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
DeserializationListener = Listener;
}
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
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 {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
class ASTSelectorLookupTrait {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader &Reader;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +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
public:
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 Selector external_key_type;
typedef external_key_type internal_key_type;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTSelectorLookupTrait(ASTReader &Reader, Module &F)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
: Reader(Reader), F(F) { }
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 bool EqualKey(const internal_key_type& a,
const internal_key_type& b) {
return a == b;
}
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
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
// This hopefully will just get inlined and removed by the optimizer.
static const internal_key_type&
GetInternalKey(const external_key_type& x) { return x; }
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 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char*& d) {
using namespace clang::io;
unsigned KeyLen = ReadUnalignedLE16(d);
unsigned DataLen = ReadUnalignedLE16(d);
return std::make_pair(KeyLen, DataLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Load the selector table lazily from the PCH file. This results in a 10% speedup on the Cocoa-prefixed "Hello, World!", all of which is (not surprisingly) user time. There was a tiny reduction in the size of the PCH file for Cocoa.h, because certain selectors aren't being written twice. I'm using two new tricks here that I'd like to replicate elsewhere: (1) The selectors not used in the global method pool are packed into the blob after the global method pool's on-disk hash table and stored as keys, so that all selectors are in the same blob. (2) We record the offsets of each selector key when we write it into the global method pool (or after it, in the same blob). The offset table is written as a blob, so that we don't need to pack/unpack a SmallVector with its contents. llvm-svn: 70055
2009-04-26 01:48:32 +08:00
internal_key_type ReadKey(const unsigned char* d, unsigned) {
PCH support for the global method pool (= instance and factory method pools, combined). The methods in the global method pool are lazily loaded from an on-disk hash table when Sema looks into its version of the hash tables. llvm-svn: 69989
2009-04-25 05:10:55 +08:00
using namespace clang::io;
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
SelectorTable &SelTable = Reader.getContext()->Selectors;
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 = ReadUnalignedLE16(d);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IdentifierInfo *FirstII
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
= Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
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
if (N == 0)
return SelTable.getNullarySelector(FirstII);
else if (N == 1)
return SelTable.getUnarySelector(FirstII);
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<IdentifierInfo *, 16> Args;
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
Args.push_back(FirstII);
for (unsigned I = 1; I != N; ++I)
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)));
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
Fix lots of PCH crashes caused by the new assertions in llvm::SmallVector, using data() instead of &[0]. The PCH testsuite now runs cleanly (again). llvm-svn: 72292
2009-05-23 06:45:36 +08:00
return SelTable.getSelector(N, Args.data());
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
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 ReadData(Selector, const unsigned char* d, unsigned DataLen) {
using namespace clang::io;
data_type Result;
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
unsigned NumInstanceMethods = ReadUnalignedLE16(d);
unsigned NumFactoryMethods = ReadUnalignedLE16(d);
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
// Load instance methods
ObjCMethodList *Prev = 0;
for (unsigned I = 0; I != NumInstanceMethods; ++I) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCMethodDecl *Method
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
= Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d));
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
if (!Result.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
// This is the first method, which is the easy case.
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
Result.Instance.Method = Method;
Prev = &Result.Instance;
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
continue;
}
Allocate 'ObjCMethodList' objects (owned by Sema) using Sema's BumpPtrAllocator. Previously they were not getting freed. Fixes <rdar://problem/7635663>. llvm-svn: 95834
2010-02-11 08:53:01 +08:00
ObjCMethodList *Mem =
Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
Prev->Next = new (Mem) ObjCMethodList(Method, 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
Prev = Prev->Next;
}
// Load factory methods
Prev = 0;
for (unsigned I = 0; I != NumFactoryMethods; ++I) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
ObjCMethodDecl *Method
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
= Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d));
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
if (!Result.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
// This is the first method, which is the easy case.
Store the IDs of selectors in the PCH file explicitly. llvm-svn: 110219
2010-08-05 01:20:04 +08:00
Result.Factory.Method = Method;
Prev = &Result.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
continue;
}
Allocate 'ObjCMethodList' objects (owned by Sema) using Sema's BumpPtrAllocator. Previously they were not getting freed. Fixes <rdar://problem/7635663>. llvm-svn: 95834
2010-02-11 08:53:01 +08:00
ObjCMethodList *Mem =
Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
Prev->Next = new (Mem) ObjCMethodList(Method, 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
Prev = Prev->Next;
}
return Result;
}
};
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
} // end anonymous namespace
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
/// \brief The on-disk hash table used for the global method pool.
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
typedef OnDiskChainedHashTable<ASTSelectorLookupTrait>
ASTSelectorLookupTable;
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
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
namespace clang {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
class ASTIdentifierLookupTrait {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader &Reader;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F;
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
// If we know the IdentifierInfo in advance, it is here and we will
// not build a new one. Used when deserializing information about an
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// identifier that was constructed before the AST file was read.
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
IdentifierInfo *KnownII;
public:
typedef IdentifierInfo * data_type;
typedef const std::pair<const char*, unsigned> external_key_type;
typedef external_key_type internal_key_type;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTIdentifierLookupTrait(ASTReader &Reader, Module &F,
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
IdentifierInfo *II = 0)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
: Reader(Reader), F(F), KnownII(II) { }
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
static bool EqualKey(const internal_key_type& a,
const internal_key_type& b) {
return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0
: false;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
static unsigned ComputeHash(const internal_key_type& a) {
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
return llvm::HashString(StringRef(a.first, a.second));
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
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
// This hopefully will just get inlined and removed by the optimizer.
static const internal_key_type&
GetInternalKey(const external_key_type& x) { return x; }
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
// This hopefully will just get inlined and removed by the optimizer.
static const external_key_type&
GetExternalKey(const internal_key_type& x) { return x; }
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
static std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char*& d) {
using namespace clang::io;
Revert my changes that try to avoid creating StringMap entries for identifiers. They don't yet work, but will inhibit future optimizations. llvm-svn: 70071
2009-04-26 04:26:24 +08:00
unsigned DataLen = ReadUnalignedLE16(d);
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
unsigned KeyLen = ReadUnalignedLE16(d);
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
return std::make_pair(KeyLen, DataLen);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
static std::pair<const char*, unsigned>
ReadKey(const unsigned char* d, unsigned n) {
assert(n >= 2 && d[n-1] == '\0');
return std::make_pair((const char*) d, n-1);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IdentifierInfo *ReadData(const internal_key_type& k,
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
const unsigned char* d,
unsigned DataLen) {
using namespace clang::io;
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
IdentID ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
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
bool IsInteresting = ID & 0x01;
// Wipe out the "is interesting" bit.
ID = ID >> 1;
if (!IsInteresting) {
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
// For uninteresting identifiers, just build the IdentifierInfo
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
// and associate it with the persistent ID.
IdentifierInfo *II = KnownII;
if (!II)
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
II = &Reader.getIdentifierTable().getOwn(StringRef(k.first,
Make more use of llvm::StringRef in various APIs. In particular, don't use the deprecated forms of llvm::StringMap::GetOrCreateValue(). llvm-svn: 133515
2011-06-21 23:13:30 +08:00
k.second));
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
Reader.SetIdentifierInfo(ID, II);
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
II->setIsFromAST();
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
return 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
unsigned Bits = ReadUnalignedLE16(d);
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
bool CPlusPlusOperatorKeyword = Bits & 0x01;
Bits >>= 1;
-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
bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
Bits >>= 1;
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
bool Poisoned = Bits & 0x01;
Bits >>= 1;
bool ExtensionToken = Bits & 0x01;
Bits >>= 1;
bool hasMacroDefinition = Bits & 0x01;
Bits >>= 1;
unsigned ObjCOrBuiltinID = Bits & 0x3FF;
Bits >>= 10;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Lazy loading of builtins for precompiled headers. PCH files now contain complete information about builtins, including any declarations that have been synthesized as part of building the PCH file. When using a PCH file, we do not initialize builtins at all; when needed, they'll be found in the PCH file. This optimization translations into a 9% speedup for "Hello, World!" with Carbon.h as a prefix header and roughly a 5% speedup for 403.gcc with its prefix header. We're also reading less of the PCH file for "Hello, World!": *** PCH Statistics: 286/20693 types read (1.382110%) 1630/59230 declarations read (2.751984%) 764/44914 identifiers read (1.701029%) 1/32954 statements read (0.003035%) 5/6187 macros read (0.080815%) down from *** PCH Statistics: 411/20693 types read (1.986179%) 2553/59230 declarations read (4.310316%) 1093/44646 identifiers read (2.448148%) 1/32954 statements read (0.003035%) 21/6187 macros read (0.339421%) llvm-svn: 69815
2009-04-23 02:49:13 +08:00
assert(Bits == 0 && "Extra bits in the identifier?");
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 -= 6;
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
// Build the IdentifierInfo itself and link the identifier ID with
// the new IdentifierInfo.
IdentifierInfo *II = KnownII;
if (!II)
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
II = &Reader.getIdentifierTable().getOwn(StringRef(k.first,
Make more use of llvm::StringRef in various APIs. In particular, don't use the deprecated forms of llvm::StringMap::GetOrCreateValue(). llvm-svn: 133515
2011-06-21 23:13:30 +08:00
k.second));
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
Reader.SetIdentifierInfo(ID, 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
// Set or check the various bits in the IdentifierInfo structure.
-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
// Token IDs are read-only.
if (HasRevertedTokenIDToIdentifier)
II->RevertTokenIDToIdentifier();
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
II->setObjCOrBuiltinID(ObjCOrBuiltinID);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(II->isExtensionToken() == ExtensionToken &&
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
"Incorrect extension token flag");
(void)ExtensionToken;
II->setIsPoisoned(Poisoned);
assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
"Incorrect C++ operator keyword flag");
(void)CPlusPlusOperatorKeyword;
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 this identifier is a macro, deserialize the macro
// definition.
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
uint32_t Offset = ReadUnalignedLE32(d);
Make the deserialization of macro definitions lazy, so that we can load identifiers without loading their corresponding macro definitions. This is likely to improve PCH performance slightly, and reduces deserialization stack depth considerably when using preprocessor metaprogramming. llvm-svn: 117750
2010-10-30 08:23:06 +08:00
Reader.SetIdentifierIsMacro(II, F, Offset);
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;
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
// Read all of the declarations visible at global scope with this
// name.
fix test/PCH/method_pool.m llvm-svn: 70263
2009-04-28 06:17:41 +08:00
if (Reader.getContext() == 0) return II;
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
if (DataLen > 0) {
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<uint32_t, 4> DeclIDs;
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
for (; DataLen > 0; DataLen -= 4)
Clean up the rest of the local -> global declaration ID mappings within the ASTReader (I hope). llvm-svn: 135720
2011-07-22 07:29:11 +08:00
DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d)));
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
Reader.SetGloballyVisibleDecls(II, DeclIDs);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
II->setIsFromAST();
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
return II;
Allow some differences between the predefines buffer used to build a PCH file and the predefines buffer used when including the PCH file. We (explicitly) detect conflicting macro definitions (rejecting the PCH file) and about missing macro definitions (they'll be automatically pulled from the PCH file anyway). We're missing some checking to make sure that new macro definitions won't have any impact on the PCH file itself (e.g., #define'ing an identifier that the PCH file used). llvm-svn: 70316
2009-04-29 02:58:38 +08:00
}
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
};
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
} // end anonymous namespace
Allow some differences between the predefines buffer used to build a PCH file and the predefines buffer used when including the PCH file. We (explicitly) detect conflicting macro definitions (rejecting the PCH file) and about missing macro definitions (they'll be automatically pulled from the PCH file anyway). We're missing some checking to make sure that new macro definitions won't have any impact on the PCH file itself (e.g., #define'ing an identifier that the PCH file used). llvm-svn: 70316
2009-04-29 02:58:38 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
/// \brief The on-disk hash table used to contain information about
/// all of the identifiers in the program.
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait>
ASTIdentifierLookupTable;
Allow some differences between the predefines buffer used to build a PCH file and the predefines buffer used when including the PCH file. We (explicitly) detect conflicting macro definitions (rejecting the PCH file) and about missing macro definitions (they'll be automatically pulled from the PCH file anyway). We're missing some checking to make sure that new macro definitions won't have any impact on the PCH file itself (e.g., #define'ing an identifier that the PCH file used). llvm-svn: 70316
2009-04-29 02:58:38 +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
namespace {
class ASTDeclContextNameLookupTrait {
ASTReader &Reader;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F;
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +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
public:
/// \brief Pair of begin/end iterators for DeclIDs.
Use local-to-global mapping appropriately for macro definitions in the ASTReader llvm-svn: 136410
2011-07-29 06:16:57 +08:00
///
/// Note that these declaration IDs are local to the module that contains this
/// particular lookup t
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
typedef std::pair<DeclID *, DeclID *> data_type;
/// \brief Special internal key for declaration names.
/// The hash table creates keys for comparison; we do not create
/// a DeclarationName for the internal key to avoid deserializing types.
struct DeclNameKey {
DeclarationName::NameKind Kind;
uint64_t Data;
DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { }
};
typedef DeclarationName external_key_type;
typedef DeclNameKey internal_key_type;
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
explicit ASTDeclContextNameLookupTrait(ASTReader &Reader,
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F)
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
: Reader(Reader), F(F) { }
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
static bool EqualKey(const internal_key_type& a,
const internal_key_type& b) {
return a.Kind == b.Kind && a.Data == b.Data;
}
unsigned ComputeHash(const DeclNameKey &Key) const {
llvm::FoldingSetNodeID ID;
ID.AddInteger(Key.Kind);
switch (Key.Kind) {
case DeclarationName::Identifier:
case DeclarationName::CXXLiteralOperatorName:
ID.AddString(((IdentifierInfo*)Key.Data)->getName());
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
ID.AddInteger((TypeID)Key.Data);
break;
case DeclarationName::CXXOperatorName:
ID.AddInteger((OverloadedOperatorKind)Key.Data);
break;
case DeclarationName::CXXUsingDirective:
break;
}
return ID.ComputeHash();
}
internal_key_type GetInternalKey(const external_key_type& Name) const {
DeclNameKey Key;
Key.Kind = Name.getNameKind();
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
Key.Data = (uint64_t)Name.getAsIdentifierInfo();
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
Key.Data = Reader.GetTypeID(Name.getCXXNameType());
break;
case DeclarationName::CXXOperatorName:
Key.Data = Name.getCXXOverloadedOperator();
break;
case DeclarationName::CXXLiteralOperatorName:
Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
break;
case DeclarationName::CXXUsingDirective:
break;
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +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
return Key;
}
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
external_key_type GetExternalKey(const internal_key_type& Key) const {
ASTContext *Context = Reader.getContext();
switch (Key.Kind) {
case DeclarationName::Identifier:
return DeclarationName((IdentifierInfo*)Key.Data);
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
return DeclarationName(Selector(Key.Data));
case DeclarationName::CXXConstructorName:
return Context->DeclarationNames.getCXXConstructorName(
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Context->getCanonicalType(Reader.getLocalType(F, Key.Data)));
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
case DeclarationName::CXXDestructorName:
return Context->DeclarationNames.getCXXDestructorName(
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Context->getCanonicalType(Reader.getLocalType(F, Key.Data)));
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
case DeclarationName::CXXConversionFunctionName:
return Context->DeclarationNames.getCXXConversionFunctionName(
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Context->getCanonicalType(Reader.getLocalType(F, Key.Data)));
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
case DeclarationName::CXXOperatorName:
return Context->DeclarationNames.getCXXOperatorName(
(OverloadedOperatorKind)Key.Data);
case DeclarationName::CXXLiteralOperatorName:
return Context->DeclarationNames.getCXXLiteralOperatorName(
(IdentifierInfo*)Key.Data);
case DeclarationName::CXXUsingDirective:
return DeclarationName::getUsingDirectiveName();
}
llvm_unreachable("Invalid Name Kind ?");
}
Introduce the mechanism for building an AST on-disk hash table for name lookup inside a DeclContext but don't use it yet. llvm-svn: 111635
2010-08-21 00:04:27 +08:00
static std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char*& d) {
using namespace clang::io;
unsigned KeyLen = ReadUnalignedLE16(d);
unsigned DataLen = ReadUnalignedLE16(d);
return std::make_pair(KeyLen, DataLen);
}
internal_key_type ReadKey(const unsigned char* d, unsigned) {
using namespace clang::io;
DeclNameKey Key;
Key.Kind = (DeclarationName::NameKind)*d++;
switch (Key.Kind) {
case DeclarationName::Identifier:
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
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
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Key.Data =
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
(uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d))
.getAsOpaquePtr();
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
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
Key.Data = Reader.getGlobalTypeID(F, ReadUnalignedLE32(d)); // TypeID
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
break;
case DeclarationName::CXXOperatorName:
Key.Data = *d++; // OverloadedOperatorKind
break;
case DeclarationName::CXXLiteralOperatorName:
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
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
break;
case DeclarationName::CXXUsingDirective:
break;
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +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
return Key;
}
data_type ReadData(internal_key_type, const unsigned char* d,
unsigned DataLen) {
using namespace clang::io;
unsigned NumDecls = ReadUnalignedLE16(d);
DeclID *Start = (DeclID *)d;
return std::make_pair(Start, Start + NumDecls);
}
};
} // end anonymous namespace
/// \brief The on-disk hash table used for the DeclContext's Name lookup table.
typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait>
ASTDeclContextNameLookupTable;
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
bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor,
const std::pair<uint64_t, uint64_t> &Offsets,
DeclContextInfo &Info) {
SavedStreamPosition SavedPosition(Cursor);
// First the lexical decls.
if (Offsets.first != 0) {
Cursor.JumpToBit(Offsets.first);
RecordData Record;
const char *Blob;
unsigned BlobLen;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
if (RecCode != DECL_CONTEXT_LEXICAL) {
Error("Expected lexical block");
return true;
}
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
Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
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
} else {
Info.LexicalDecls = 0;
Info.NumLexicalDecls = 0;
}
// Now the lookup table.
if (Offsets.second != 0) {
Cursor.JumpToBit(Offsets.second);
RecordData Record;
const char *Blob;
unsigned BlobLen;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
if (RecCode != DECL_CONTEXT_VISIBLE) {
Error("Expected visible lookup table block");
return true;
}
Info.NameLookupTableData
= ASTDeclContextNameLookupTable::Create(
(const unsigned char *)Blob + Record[0],
(const unsigned char *)Blob,
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
ASTDeclContextNameLookupTrait(*this, *Info.F));
Correctly initialize the visible decls pointer if there are no visible decls for a record. llvm-svn: 111879
2010-08-24 08:50:00 +08:00
} else {
Info.NameLookupTableData = 0;
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
}
return false;
}
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 ASTReader::Error(StringRef Msg) {
Fix a crash when ASTReader emits diagnostic when another one is in flight. Fixes rdar//9334563. llvm-svn: 130162
2011-04-26 06:23:56 +08:00
Error(diag::err_fe_pch_malformed, Msg);
}
void ASTReader::Error(unsigned DiagID,
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 Arg1, StringRef Arg2) {
Fix a crash when ASTReader emits diagnostic when another one is in flight. Fixes rdar//9334563. llvm-svn: 130162
2011-04-26 06:23:56 +08:00
if (Diags.isDiagnosticInFlight())
Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
else
Diag(DiagID) << Arg1 << Arg2;
Allow some differences between the predefines buffer used to build a PCH file and the predefines buffer used when including the PCH file. We (explicitly) detect conflicting macro definitions (rejecting the PCH file) and about missing macro definitions (they'll be automatically pulled from the PCH file anyway). We're missing some checking to make sure that new macro definitions won't have any impact on the PCH file itself (e.g., #define'ing an identifier that the PCH file used). llvm-svn: 70316
2009-04-29 02:58:38 +08:00
}
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
/// \brief Tell the AST listener about the predefines buffers in the chain.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
bool ASTReader::CheckPredefinesBuffers() {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (Listener)
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
Redo how PCH handles its implicit include. Instead of treating this specially in the front-end (as far as the preprocessor goes), follow the usual logic of inserting the (original include path) name into the predefines buffer. This pushes the responsibility for handling this to PCH instead of the front-end. In PCH this requires being a little more clever when we diff the predefines buffers. Neither of these solutions are particularly great, I think what we eventually should do is something like gcc where we insert a special marker to indicate the PCH file, but then run the preprocessor as usual. This would be clearer and would allow us to drop the overly clever predefines handling. llvm-svn: 86806
2009-11-11 13:29:04 +08:00
ActualOriginalFileName,
Preserve what the user passed to -include when emitting .d files. Fixes PR8974! llvm-svn: 126334
2011-02-24 05:16:44 +08:00
SuggestedPredefines,
FileMgr);
Allow some differences between the predefines buffer used to build a PCH file and the predefines buffer used when including the PCH file. We (explicitly) detect conflicting macro definitions (rejecting the PCH file) and about missing macro definitions (they'll be automatically pulled from the PCH file anyway). We're missing some checking to make sure that new macro definitions won't have any impact on the PCH file itself (e.g., #define'ing an identifier that the PCH file used). llvm-svn: 70316
2009-04-29 02:58:38 +08:00
return false;
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +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
//===----------------------------------------------------------------------===//
// Source Manager Deserialization
//===----------------------------------------------------------------------===//
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
/// \brief Read the line table in the source manager block.
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
/// \returns true if there was an error.
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
bool ASTReader::ParseLineTable(Module &F,
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
SmallVectorImpl<uint64_t> &Record) {
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
unsigned Idx = 0;
LineTableInfo &LineTable = SourceMgr.getLineTable();
// Parse the file names
Make the reading of the line table from a PCH file more robust against the unlikely event that the filename IDs in the stored line table end up being different from the filename IDs in the newly-created line table. llvm-svn: 68965
2009-04-14 01:12:42 +08:00
std::map<int, int> FileIDs;
for (int I = 0, N = Record[Idx++]; I != N; ++I) {
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
// Extract the file name
unsigned FilenameLen = Record[Idx++];
std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
Idx += FilenameLen;
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
MaybeAddSystemRootToFilename(Filename);
Make more use of llvm::StringRef in various APIs. In particular, don't use the deprecated forms of llvm::StringMap::GetOrCreateValue(). llvm-svn: 133515
2011-06-21 23:13:30 +08:00
FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
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
}
// Parse the line entries
std::vector<LineEntry> Entries;
while (Idx < Record.size()) {
Fix broken reading of "#lines" from PCH. llvm-svn: 107470
2010-07-02 19:55:05 +08:00
int FID = Record[Idx++];
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
assert(FID >= 0 && "Serialized line entries for non-local file.");
// Remap FileID from 1-based old view.
FID += F.SLocEntryBaseID - 1;
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
// Extract the line entries
unsigned NumEntries = Record[Idx++];
Fix broken reading of "#lines" from PCH. llvm-svn: 107470
2010-07-02 19:55:05 +08:00
assert(NumEntries && "Numentries is 00000");
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
Entries.clear();
Entries.reserve(NumEntries);
for (unsigned I = 0; I != NumEntries; ++I) {
unsigned FileOffset = Record[Idx++];
unsigned LineNo = Record[Idx++];
Fix broken reading of "#lines" from PCH. llvm-svn: 107470
2010-07-02 19:55:05 +08:00
int FilenameID = FileIDs[Record[Idx++]];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SrcMgr::CharacteristicKind FileKind
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
= (SrcMgr::CharacteristicKind)Record[Idx++];
unsigned IncludeOffset = Record[Idx++];
Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
FileKind, IncludeOffset));
}
LineTable.AddEntry(FID, Entries);
}
return false;
}
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
namespace {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
class ASTStatData {
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:
const ino_t ino;
const dev_t dev;
const mode_t mode;
const time_t mtime;
const off_t size;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
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
: ino(i), dev(d), mode(mo), mtime(m), size(s) {}
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
};
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
class ASTStatLookupTrait {
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 *external_key_type;
typedef const char *internal_key_type;
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
typedef ASTStatData data_type;
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
}
static internal_key_type GetInternalKey(const char *path) { return path; }
static bool EqualKey(internal_key_type a, internal_key_type b) {
return strcmp(a, b) == 0;
}
static std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char*& d) {
unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
unsigned DataLen = (unsigned) *d++;
return std::make_pair(KeyLen + 1, DataLen);
}
static internal_key_type ReadKey(const unsigned char *d, unsigned) {
return (const char *)d;
}
static data_type ReadData(const internal_key_type, const unsigned char *d,
unsigned /*DataLen*/) {
using namespace clang::io;
ino_t ino = (ino_t) ReadUnalignedLE32(d);
dev_t dev = (dev_t) ReadUnalignedLE32(d);
mode_t mode = (mode_t) ReadUnalignedLE16(d);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
time_t mtime = (time_t) ReadUnalignedLE64(d);
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
off_t size = (off_t) ReadUnalignedLE64(d);
return data_type(ino, dev, mode, mtime, size);
}
};
/// \brief stat() cache for precompiled headers.
///
/// This cache is very similar to the stat cache used by pretokenized
/// headers.
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
class ASTStatCache : public FileSystemStatCache {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
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
CacheTy *Cache;
unsigned &NumStatHits, &NumStatMisses;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
public:
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
ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
unsigned &NumStatHits, unsigned &NumStatMisses)
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
: Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
Cache = CacheTy::Create(Buckets, Base);
}
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
~ASTStatCache() { delete Cache; }
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
change the 'is directory' indicator to be a null-or-not pointer that is passed down through the APIs, and make FileSystemStatCache::get be the one that filters out directory lookups that hit files. This also paves the way to have stat queries be able to return opened files. llvm-svn: 120060
2010-11-24 05:17:56 +08:00
LookupResult getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// Do the lookup for the file's data in the AST file.
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
CacheTy::iterator I = Cache->find(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
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// If we don't get a hit in the AST file just forward to 'stat'.
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
if (I == Cache->end()) {
++NumStatMisses;
change the 'is directory' indicator to be a null-or-not pointer that is passed down through the APIs, and make FileSystemStatCache::get be the one that filters out directory lookups that hit files. This also paves the way to have stat queries be able to return opened files. llvm-svn: 120060
2010-11-24 05:17:56 +08:00
return statChained(Path, StatBuf, FileDescriptor);
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
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
++NumStatHits;
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTStatData Data = *I;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
StatBuf.st_ino = Data.ino;
StatBuf.st_dev = Data.dev;
StatBuf.st_mtime = Data.mtime;
StatBuf.st_mode = Data.mode;
StatBuf.st_size = Data.size;
simplify the cache miss handling code, eliminating CacheMissing. llvm-svn: 120038
2010-11-24 04:05:15 +08:00
return CacheExists;
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
}
};
} // end anonymous namespace
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
/// \brief Read a source manager block
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(Module &F) {
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 SrcMgr;
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
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
First baby steps towards PCHReader being able to keep track of multiple PCH files. WIP llvm-svn: 108537
2010-07-17 01:50: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
// Set the source-location entry cursor to the current position in
// the stream. This cursor will be used to read the contents of the
// source manager block initially, and then lazily read
// source-location entries as needed.
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
SLocEntryCursor = F.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
// The stream itself is going to skip over the source manager block.
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
if (F.Stream.SkipBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
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
return Failure;
}
// Enter the source manager block.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed source manager block record in AST file");
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +08:00
return Failure;
}
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
RecordData Record;
while (true) {
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
unsigned Code = SLocEntryCursor.ReadCode();
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 (Code == llvm::bitc::END_BLOCK) {
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 (SLocEntryCursor.ReadBlockEnd()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("error at end of Source Manager block in AST file");
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +08:00
return Failure;
}
return Success;
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
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
// No known subblocks, always skip them.
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
SLocEntryCursor.ReadSubBlockID();
if (SLocEntryCursor.SkipBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +08:00
return Failure;
}
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
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
if (Code == llvm::bitc::DEFINE_ABBREV) {
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
SLocEntryCursor.ReadAbbrevRecord();
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
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
// Read a record.
const char *BlobStart;
unsigned BlobLen;
Record.clear();
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
switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
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
default: // Default behavior: ignore.
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SM_SLOC_FILE_ENTRY:
case SM_SLOC_BUFFER_ENTRY:
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
case 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
// Once we hit one of the source location entries, we're done.
return Success;
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
}
}
}
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
/// \brief 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.
static std::string
resolveFileRelativeToOriginalDir(const std::string &Filename,
const std::string &OriginalDir,
const std::string &CurrDir) {
assert(OriginalDir != CurrDir &&
"No point trying to resolve the file if the PCH dir didn't change");
using namespace llvm::sys;
llvm::SmallString<128> filePath(Filename);
fs::make_absolute(filePath);
assert(path::is_absolute(OriginalDir));
llvm::SmallString<128> currPCHPath(CurrDir);
path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
fileDirE = path::end(path::parent_path(filePath));
path::const_iterator origDirI = path::begin(OriginalDir),
origDirE = path::end(OriginalDir);
// Skip the common path components from filePath and OriginalDir.
while (fileDirI != fileDirE && origDirI != origDirE &&
*fileDirI == *origDirI) {
++fileDirI;
++origDirI;
}
for (; origDirI != origDirE; ++origDirI)
path::append(currPCHPath, "..");
path::append(currPCHPath, fileDirI, fileDirE);
path::append(currPCHPath, path::filename(Filename));
return currPCHPath.str();
}
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
/// \brief Read in the source location entry with the given ID.
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) {
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 (ID == 0)
return Success;
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("source location entry ID out-of-range for AST file");
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
return Failure;
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module *F = GlobalSLocEntryMap.find(-ID)->second;
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
F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
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 BaseOffset = F->SLocEntryBaseOffset;
First baby steps towards PCHReader being able to keep track of multiple PCH files. WIP llvm-svn: 108537
2010-07-17 01:50: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
++NumSLocEntriesRead;
unsigned Code = SLocEntryCursor.ReadCode();
if (Code == llvm::bitc::END_BLOCK ||
Code == llvm::bitc::ENTER_SUBBLOCK ||
Code == llvm::bitc::DEFINE_ABBREV) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("incorrectly-formatted source location entry in AST file");
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
return Failure;
}
RecordData Record;
const char *BlobStart;
unsigned BlobLen;
switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
default:
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("incorrectly-formatted source location entry in AST file");
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
return Failure;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SM_SLOC_FILE_ENTRY: {
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
std::string Filename(BlobStart, BlobStart + BlobLen);
MaybeAddSystemRootToFilename(Filename);
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
const FileEntry *File = FileMgr.getFile(Filename);
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
if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
OriginalDir != CurrentDir) {
std::string resolved = resolveFileRelativeToOriginalDir(Filename,
OriginalDir,
CurrentDir);
if (!resolved.empty())
File = FileMgr.getFile(resolved);
}
TextDiagnosticPrinter.cpp: Show diagnostics as far as possible even with invalid PresomedLoc, instead of just silencing it. FileManager.cpp: Allow virtual files in nonexistent directories. FileManager.cpp: Close FileDescriptor for virtual files that correspond to actual files. FileManager.cpp: Enable virtual files to be created even for files that were flagged as NON_EXISTENT_FILE, e.g. by a prior (unsuccessful) addFile(). ASTReader.cpp: Read a PCH even if the original source files cannot be found. Add a test for reading a PCH of a file that has been removed and diagnostics referencing that file. llvm-svn: 124374
2011-01-27 18:55:51 +08:00
if (File == 0)
File = FileMgr.getVirtualFile(Filename, (off_t)Record[4],
(time_t)Record[5]);
If PCH refers to a file that doesn't exist anymore, emit a nice error like: fatal error: could not find file '1.h' referenced by PCH file instead of aborting with an assertion failure, PR4219 llvm-svn: 73371
2009-06-15 12:35:16 +08:00
if (File == 0) {
std::string ErrorStr = "could not find file '";
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
ErrorStr += Filename;
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ErrorStr += "' referenced by AST file";
If PCH refers to a file that doesn't exist anymore, emit a nice error like: fatal error: could not find file '1.h' referenced by PCH file instead of aborting with an assertion failure, PR4219 llvm-svn: 73371
2009-06-15 12:35:16 +08:00
Error(ErrorStr.c_str());
return Failure;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
if (Record.size() < 6) {
Add bounds check in PCHReader. when reading source file entry record llvm-svn: 98873
2010-03-19 05:23:05 +08:00
Error("source location entry is incorrect");
return Failure;
}
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
if (!DisableValidation &&
((off_t)Record[4] != File->getSize()
On Windows, disable the modification-time check for files used in precompiled headers and/or when reading the contents of the file into memory. These checks seem to be causing spurious regression-test failures on Windows. llvm-svn: 100866
2010-04-09 23:54:22 +08:00
#if !defined(LLVM_ON_WIN32)
// In our regression testing, the Windows file system seems to
// have inconsistent modification times that sometimes
// erroneously trigger this error-handling path.
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
|| (time_t)Record[5] != File->getModificationTime()
On Windows, disable the modification-time check for files used in precompiled headers and/or when reading the contents of the file into memory. These checks seem to be causing spurious regression-test failures on Windows. llvm-svn: 100866
2010-04-09 23:54:22 +08:00
#endif
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
)) {
Fix a crash when ASTReader emits diagnostic when another one is in flight. Fixes rdar//9334563. llvm-svn: 130162
2011-04-26 06:23:56 +08:00
Error(diag::err_fe_pch_file_modified, Filename);
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
return Failure;
}
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
SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
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
// This is the module's main file.
IncludeLoc = getImportLocation(F);
}
FileID FID = SourceMgr.createFileID(File, IncludeLoc,
tidy up. Split FileManager::getBufferForFile into two copies, since they are fundamentally different operations and the StringRef one should go away (it shouldn't be part of FileManager at least). Remove some dead arguments. llvm-svn: 120013
2010-11-23 17:19:42 +08:00
(SrcMgr::CharacteristicKind)Record[2],
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
ID, BaseOffset + Record[0]);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
if (Record[3])
const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile())
.setHasLineDirectives();
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
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
break;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SM_SLOC_BUFFER_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
const char *Name = BlobStart;
unsigned Offset = Record[0];
unsigned Code = SLocEntryCursor.ReadCode();
Record.clear();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
unsigned RecCode
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
= SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (RecCode != SM_SLOC_BUFFER_BLOB) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("AST record has invalid code");
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
return Failure;
}
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
llvm::MemoryBuffer *Buffer
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
= llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
Match MemoryBuffer API changes. llvm-svn: 100484
2010-04-06 06:42:27 +08:00
Name);
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
FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID,
BaseOffset + Offset);
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
if (strcmp(Name, "<built-in>") == 0) {
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
PCHPredefinesBlock Block = {
BufferID,
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(BlobStart, BlobLen - 1)
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
};
PCHPredefinesBuffers.push_back(Block);
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
}
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
break;
}
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
case SM_SLOC_EXPANSION_ENTRY: {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
Rename create(MacroArg)InstantiationLoc to create(MacroArg)ExpansionLoc. llvm-svn: 136054
2011-07-26 11:03:05 +08:00
SourceMgr.createExpansionLoc(SpellingLoc,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ReadSourceLocation(*F, Record[2]),
ReadSourceLocation(*F, Record[3]),
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[4],
ID,
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
BaseOffset + Record[0]);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
break;
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
}
return Success;
}
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
/// \brief Find the location where the module F is imported.
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
SourceLocation ASTReader::getImportLocation(Module *F) {
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 (F->ImportLoc.isValid())
return F->ImportLoc;
// Otherwise we have a PCH. It's considered to be "imported" at the first
// location of its includer.
if (F->Loaders.empty() || !F->Loaders[0]) {
// Main file is the importer. We assume that it is the first entry in the
// entry table. We can't ask the manager, because at the time of PCH loading
// the main file entry doesn't exist yet.
// The very first entry is the invalid instantiation loc, which takes up
// offsets 0 and 1.
return SourceLocation::getFromRawEncoding(2U);
}
return F->Loaders[0]->FirstLoc;
}
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
/// specified cursor. Read the abbreviations that are at the top of the block
/// and then leave the cursor pointing into the block.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
unsigned BlockID) {
if (Cursor.EnterSubBlock(BlockID)) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
return Failure;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
while (true) {
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
uint64_t Offset = Cursor.GetCurrentBitNo();
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
unsigned Code = Cursor.ReadCode();
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
// We expect all abbrevs to be at the start of the 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
if (Code != llvm::bitc::DEFINE_ABBREV) {
Cursor.JumpToBit(Offset);
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
return false;
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
}
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
Cursor.ReadAbbrevRecord();
}
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
PreprocessedEntity *ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
assert(PP && "Forgot to set Preprocessor ?");
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
llvm::BitstreamCursor &Stream = F.MacroCursor;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
// Keep track of where we are in the stream, then jump back there
// after reading this macro.
SavedStreamPosition SavedPosition(Stream);
Stream.JumpToBit(Offset);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
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
SmallVector<IdentifierInfo*, 16> MacroArgs;
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
MacroInfo *Macro = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
while (true) {
unsigned Code = Stream.ReadCode();
switch (Code) {
case llvm::bitc::END_BLOCK:
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
return 0;
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
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
case llvm::bitc::ENTER_SUBBLOCK:
// No known subblocks, always skip them.
Stream.ReadSubBlockID();
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 (Stream.SkipBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
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
return 0;
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
}
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
continue;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
case llvm::bitc::DEFINE_ABBREV:
Stream.ReadAbbrevRecord();
continue;
default: break;
}
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
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
// Read a record.
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
const char *BlobStart = 0;
unsigned BlobLen = 0;
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
Record.clear();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
PreprocessorRecordTypes RecType =
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
(PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
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
BlobLen);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
switch (RecType) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PP_MACRO_OBJECT_LIKE:
case PP_MACRO_FUNCTION_LIKE: {
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 we already have a macro, that means that we've hit the end
// of the definition of the macro we were looking for. We're
// done.
if (Macro)
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
return 0;
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
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
IdentifierInfo *II = getLocalIdentifier(F, Record[0]);
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 (II == 0) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("macro must have a name in AST file");
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
return 0;
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
}
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation Loc = ReadSourceLocation(F, Record[1]);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
bool isUsed = Record[2];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
MacroInfo *MI = PP->AllocateMacroInfo(Loc);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
MI->setIsUsed(isUsed);
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
MI->setIsFromAST();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
unsigned NextIndex = 3;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (RecType == PP_MACRO_FUNCTION_LIKE) {
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
// Decode function-like macro info.
bool isC99VarArgs = Record[3];
bool isGNUVarArgs = Record[4];
MacroArgs.clear();
unsigned NumArgs = Record[5];
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
NextIndex = 6 + NumArgs;
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
for (unsigned i = 0; i != NumArgs; ++i)
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
MacroArgs.push_back(getLocalIdentifier(F, Record[6+i]));
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
// Install function-like macro info.
MI->setIsFunctionLike();
if (isC99VarArgs) MI->setIsC99Varargs();
if (isGNUVarArgs) MI->setIsGNUVarargs();
Fix lots of PCH crashes caused by the new assertions in llvm::SmallVector, using data() instead of &[0]. The PCH testsuite now runs cleanly (again). llvm-svn: 72292
2009-05-23 06:45:36 +08:00
MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PP->getPreprocessorAllocator());
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
}
// Finally, install the macro.
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PP->setMacroInfo(II, MI);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
// Remember that we saw this macro last so that we add the tokens that
// form its body to it.
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
Macro = MI;
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 (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) {
// We have a macro definition. Load it now.
PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro,
Use local-to-global mapping appropriately for macro definitions in the ASTReader llvm-svn: 136410
2011-07-29 06:16:57 +08:00
getLocalMacroDefinition(F, Record[NextIndex]));
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
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
++NumMacrosRead;
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
break;
}
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
case PP_TOKEN: {
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 we see a TOKEN before a PP_MACRO_*, then the file is
// erroneous, just pretend we didn't see this.
if (Macro == 0) break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
Token Tok;
Tok.startToken();
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Tok.setLocation(ReadSourceLocation(F, Record[0]));
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
Tok.setLength(Record[1]);
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
if (IdentifierInfo *II = getLocalIdentifier(F, Record[2]))
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
Tok.setIdentifierInfo(II);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
Tok.setKind((tok::TokenKind)Record[3]);
Tok.setFlag((Token::TokenFlags)Record[4]);
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
Macro->AddTokenToBody(Tok);
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
break;
}
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
}
}
return 0;
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
PreprocessedEntity *ASTReader::LoadPreprocessedEntity(Module &F) {
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
assert(PP && "Forgot to set Preprocessor ?");
unsigned Code = F.PreprocessorDetailCursor.ReadCode();
switch (Code) {
case llvm::bitc::END_BLOCK:
return 0;
case llvm::bitc::ENTER_SUBBLOCK:
Error("unexpected subblock record in preprocessor detail block");
return 0;
case llvm::bitc::DEFINE_ABBREV:
Error("unexpected abbrevation record in preprocessor detail block");
return 0;
default:
break;
}
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
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 (!PP->getPreprocessingRecord()) {
Error("no preprocessing record");
return 0;
}
// Read the record.
PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
const char *BlobStart = 0;
unsigned BlobLen = 0;
RecordData Record;
PreprocessorDetailRecordTypes RecType =
(PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord(
Code, Record, BlobStart, BlobLen);
switch (RecType) {
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
case PPD_MACRO_EXPANSION: {
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
return PE;
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
MacroExpansion *ME =
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
new (PPRec) MacroExpansion(getLocalIdentifier(F, Record[3]),
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
SourceRange(ReadSourceLocation(F, Record[1]),
ReadSourceLocation(F, Record[2])),
Use local-to-global mapping appropriately for macro definitions in the ASTReader llvm-svn: 136410
2011-07-29 06:16:57 +08:00
getLocalMacroDefinition(F, Record[4]));
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PPRec.setLoadedPreallocatedEntity(GlobalID, ME);
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
return ME;
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
}
case PPD_MACRO_DEFINITION: {
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
return PE;
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
unsigned MacroDefID = getGlobalMacroDefinitionID(F, Record[1]);
if (MacroDefID > MacroDefinitionsLoaded.size()) {
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
Error("out-of-bounds macro definition record");
return 0;
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
}
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
// Decode the identifier info and then check again; if the macro is
// still defined and associated with the identifier,
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
IdentifierInfo *II = getLocalIdentifier(F, Record[4]);
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
if (!MacroDefinitionsLoaded[MacroDefID - 1]) {
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
MacroDefinition *MD
= new (PPRec) MacroDefinition(II,
ReadSourceLocation(F, Record[5]),
SourceRange(
ReadSourceLocation(F, Record[2]),
ReadSourceLocation(F, Record[3])));
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PPRec.setLoadedPreallocatedEntity(GlobalID, MD);
MacroDefinitionsLoaded[MacroDefID - 1] = MD;
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 (DeserializationListener)
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
DeserializationListener->MacroDefinitionRead(MacroDefID, 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
}
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
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
return MacroDefinitionsLoaded[MacroDefID - 1];
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
}
case PPD_INCLUSION_DIRECTIVE: {
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
return PE;
const char *FullFileNameStart = BlobStart + Record[3];
const FileEntry *File
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
= PP->getFileManager().getFile(StringRef(FullFileNameStart,
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
BlobLen - Record[3]));
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
// FIXME: Stable encoding
InclusionDirective::InclusionKind Kind
= static_cast<InclusionDirective::InclusionKind>(Record[5]);
InclusionDirective *ID
= new (PPRec) InclusionDirective(PPRec, Kind,
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(BlobStart, Record[3]),
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[4],
File,
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
SourceRange(ReadSourceLocation(F, Record[1]),
ReadSourceLocation(F, Record[2])));
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PPRec.setLoadedPreallocatedEntity(GlobalID, ID);
Split the serialized representation for the detailed preprocessing record away from the core processor record. The tangling of these two data structures led to some inefficiencies (e.g., deserializing all of the detailed preprocessing record when we didn't need it, such as while performing code completion) along with some unnecessary ugliness. llvm-svn: 125117
2011-02-09 05:58:10 +08:00
return ID;
}
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
}
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
Error("invalid offset in preprocessor detail block");
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
return 0;
add support for reading macros. This does all the reading (with a bunch of fixme's, e.g. for tokens with identifiers) but does not actually install them. Some details with the predefines buffer needs to be sorted out first. llvm-svn: 68828
2009-04-11 05:41:48 +08:00
}
Introduce the local-global mapping for preprocessed entities, and use it appropriately. Also, patch up a place where we were failing to map local macro definition IDs into global macro definition IDs. llvm-svn: 136411
2011-07-29 06:39:26 +08:00
PreprocessedEntityID
ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) {
// FIXME: Local-to-global mapping
return LocalID;
}
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 {
/// \brief Trait class used to search the on-disk hash table containing all of
/// the header search information.
///
/// The on-disk hash table contains a mapping from each header path to
/// information about that header (how many times it has been included, its
/// controlling macro, etc.). Note that we actually hash based on the
/// filename, and support "deep" comparisons of file names based on current
/// inode numbers, so that the search can cope with non-normalized path names
/// and symlinks.
class HeaderFileInfoTrait {
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
ASTReader &Reader;
Module &M;
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
HeaderSearch *HS;
const char *FrameworkStrings;
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
const char *SearchPath;
struct stat SearchPathStatBuf;
llvm::Optional<int> SearchPathStatResult;
int StatSimpleCache(const char *Path, struct stat *StatBuf) {
if (Path == SearchPath) {
if (!SearchPathStatResult)
SearchPathStatResult = stat(Path, &SearchPathStatBuf);
*StatBuf = SearchPathStatBuf;
return *SearchPathStatResult;
}
return stat(Path, StatBuf);
}
public:
typedef const char *external_key_type;
typedef const char *internal_key_type;
typedef HeaderFileInfo data_type;
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
HeaderFileInfoTrait(ASTReader &Reader, Module &M, HeaderSearch *HS,
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
const char *FrameworkStrings,
const char *SearchPath = 0)
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
: Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings),
SearchPath(SearchPath) { }
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
static unsigned ComputeHash(const char *path) {
return llvm::HashString(llvm::sys::path::filename(path));
}
static internal_key_type GetInternalKey(const char *path) { return path; }
bool EqualKey(internal_key_type a, internal_key_type b) {
if (strcmp(a, b) == 0)
return true;
if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
return false;
// The file names match, but the path names don't. stat() the files to
// see if they are the same.
struct stat StatBufA, StatBufB;
if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB))
return false;
return StatBufA.st_ino == StatBufB.st_ino;
}
static std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char*& d) {
unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
unsigned DataLen = (unsigned) *d++;
return std::make_pair(KeyLen + 1, DataLen);
}
static internal_key_type ReadKey(const unsigned char *d, unsigned) {
return (const char *)d;
}
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
data_type ReadData(const internal_key_type, const unsigned char *d,
unsigned DataLen) {
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
const unsigned char *End = d + DataLen;
using namespace clang::io;
HeaderFileInfo HFI;
unsigned Flags = *d++;
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
HFI.isImport = (Flags >> 5) & 0x01;
HFI.isPragmaOnce = (Flags >> 4) & 0x01;
HFI.DirInfo = (Flags >> 2) & 0x03;
HFI.Resolved = (Flags >> 1) & 0x01;
HFI.IndexHeaderMapHeader = Flags & 0x01;
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
HFI.NumIncludes = ReadUnalignedLE16(d);
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d));
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) {
// The framework offset is 1 greater than the actual offset,
// since 0 is used as an indicator for "no framework name".
StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
}
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(End == d && "Wrong data length in HeaderFileInfo deserialization");
(void)End;
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +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
// This HeaderFileInfo was externally loaded.
HFI.External = true;
return HFI;
}
};
}
/// \brief The on-disk hash table used for the global method pool.
typedef OnDiskChainedHashTable<HeaderFileInfoTrait>
HeaderFileInfoLookupTable;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F,
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
uint64_t LocalOffset) {
Make the deserialization of macro definitions lazy, so that we can load identifiers without loading their corresponding macro definitions. This is likely to improve PCH performance slightly, and reduces deserialization stack depth considerably when using preprocessor metaprogramming. llvm-svn: 117750
2010-10-30 08:23:06 +08:00
// Note that this identifier has a macro definition.
II->setHasMacroDefinition(true);
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
// Adjust the offset to a global offset.
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset;
Make the deserialization of macro definitions lazy, so that we can load identifiers without loading their corresponding macro definitions. This is likely to improve PCH performance slightly, and reduces deserialization stack depth considerably when using preprocessor metaprogramming. llvm-svn: 117750
2010-10-30 08:23:06 +08:00
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::ReadDefinedMacros() {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleReverseIterator I = ModuleMgr.rbegin(),
E = ModuleMgr.rend(); I != E; ++I) {
llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
// If there was no preprocessor block, skip this file.
if (!MacroCursor.getBitStreamReader())
continue;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
llvm::BitstreamCursor Cursor = MacroCursor;
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
Cursor.JumpToBit((*I)->MacroStartOffset);
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
RecordData Record;
while (true) {
unsigned Code = Cursor.ReadCode();
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
if (Code == llvm::bitc::END_BLOCK)
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
break;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
// No known subblocks, always skip them.
Cursor.ReadSubBlockID();
if (Cursor.SkipBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
return;
}
continue;
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
if (Code == llvm::bitc::DEFINE_ABBREV) {
Cursor.ReadAbbrevRecord();
continue;
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
// Read a record.
const char *BlobStart;
unsigned BlobLen;
Record.clear();
switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
default: // Default behavior: ignore.
break;
Teach Preprocessor::macro_begin/macro_end to lazily load all macro definitions from a precompiled header. This ensures that code-completion with macro names behaves the same with or without precompiled headers. llvm-svn: 92497
2010-01-05 03:18:44 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PP_MACRO_OBJECT_LIKE:
case PP_MACRO_FUNCTION_LIKE:
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
getLocalIdentifier(**I, Record[0]);
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PP_TOKEN:
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
// Ignore tokens.
break;
}
Teach Preprocessor::macro_begin/macro_end to lazily load all macro definitions from a precompiled header. This ensures that code-completion with macro names behaves the same with or without precompiled headers. llvm-svn: 92497
2010-01-05 03:18:44 +08:00
}
}
Make the deserialization of macro definitions lazy, so that we can load identifiers without loading their corresponding macro definitions. This is likely to improve PCH performance slightly, and reduces deserialization stack depth considerably when using preprocessor metaprogramming. llvm-svn: 117750
2010-10-30 08:23:06 +08:00
// Drain the unread macro-record offsets map.
while (!UnreadMacroRecordOffsets.empty())
LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
}
void ASTReader::LoadMacroDefinition(
llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
uint64_t Offset = Pos->second;
UnreadMacroRecordOffsets.erase(Pos);
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
RecordLocation Loc = getLocalBitOffset(Offset);
ReadMacroRecord(*Loc.F, Loc.Offset);
Make the deserialization of macro definitions lazy, so that we can load identifiers without loading their corresponding macro definitions. This is likely to improve PCH performance slightly, and reduces deserialization stack depth considerably when using preprocessor metaprogramming. llvm-svn: 117750
2010-10-30 08:23:06 +08:00
}
void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
= UnreadMacroRecordOffsets.find(II);
LoadMacroDefinition(Pos);
Teach Preprocessor::macro_begin/macro_end to lazily load all macro definitions from a precompiled header. This ensures that code-completion with macro names behaves the same with or without precompiled headers. llvm-svn: 92497
2010-01-05 03:18:44 +08:00
}
Macro definitions in AST files have their own IDs. llvm-svn: 114014
2010-09-16 03:54:06 +08:00
MacroDefinition *ASTReader::getMacroDefinition(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
if (ID == 0 || ID > MacroDefinitionsLoaded.size())
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 0;
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
if (!MacroDefinitionsLoaded[ID - 1]) {
Use a ContinuousRangeMap to map from the global macro definition ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. More cleanup/generalization, although there is more work to do for preprocessed entities. In particular, the "preallocation" scheme for preprocessed entities is not going to work well with late loading of PCH files, and it's likely we'll have to do something akin to the SourceManager's negative/positive loading. llvm-svn: 135556
2011-07-20 09:29:15 +08:00
GlobalMacroDefinitionMapType::iterator I =GlobalMacroDefinitionMap.find(ID);
assert(I != GlobalMacroDefinitionMap.end() &&
"Corrupted global macro definition map");
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F = *I->second.first;
Use a ContinuousRangeMap to map from the global macro definition ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. More cleanup/generalization, although there is more work to do for preprocessed entities. In particular, the "preallocation" scheme for preprocessed entities is not going to work well with late loading of PCH files, and it's likely we'll have to do something akin to the SourceManager's negative/positive loading. llvm-svn: 135556
2011-07-20 09:29:15 +08:00
unsigned Index = ID - 1 + I->second.second;
SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
F.PreprocessorDetailCursor.JumpToBit(F.MacroDefinitionOffsets[Index]);
LoadPreprocessedEntity(F);
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
}
Implement chained PCH support for the macro definitions stored within the "detailed" preprocessing record. llvm-svn: 115417
2010-10-03 03:29:26 +08:00
return MacroDefinitionsLoaded[ID - 1];
Implement serialization and lazy deserialization of the preprocessing record (which includes all macro instantiations and definitions). As with all lay deserialization, this introduces a new external source (here, an external preprocessing record source) that loads all of the preprocessed entities prior to iterating over the entities. The preprocessing record is an optional part of the precompiled header that is disabled by default (enabled with -detailed-preprocessing-record). When the preprocessor given to the PCH writer has a preprocessing record, that record is written into the PCH file. When the PCH reader is given a PCH file that contains a preprocessing record, it will be lazily loaded (which, effectively, implicitly adds -detailed-preprocessing-record). This is the first case where we have sections of the precompiled header that are added/removed based on a compilation flag, which is unfortunate. However, this data consumes ~550k in the PCH file for Cocoa.h (out of ~9.9MB), and there is a non-trivial cost to gathering this detailed preprocessing information, so it's too expensive to turn on by default. In the future, we should investigate a better encoding of this information. llvm-svn: 99002
2010-03-20 05:51:54 +08:00
}
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
const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
[PCH] Be conservative and check all the files the PCH references to see if a file was modified since the time the PCH was created. The parser is not fit to deal with stale PCHs, too many invariants do not hold up. rdar://9530587. llvm-svn: 132389
2011-06-01 13:43:53 +08:00
std::string Filename = filenameStrRef;
MaybeAddSystemRootToFilename(Filename);
const FileEntry *File = FileMgr.getFile(Filename);
if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
OriginalDir != CurrentDir) {
std::string resolved = resolveFileRelativeToOriginalDir(Filename,
OriginalDir,
CurrentDir);
if (!resolved.empty())
File = FileMgr.getFile(resolved);
}
return File;
}
Use local-to-global mapping appropriately for macro definitions in the ASTReader llvm-svn: 136410
2011-07-29 06:16:57 +08:00
MacroID ASTReader::getGlobalMacroDefinitionID(Module &M, unsigned LocalID) {
// FIXME: Local-to-global mapping
return LocalID;
}
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 If we are loading a relocatable PCH file, and the filename is
/// not an absolute path, add the system root to the beginning of the file
/// name.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
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 this is not a relocatable PCH file, there's nothing to do.
if (!RelocatablePCH)
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Replace all uses of PathV1::isAbsolute with PathV2::is_{absolute,relative}. llvm-svn: 122087
2010-12-18 05:22:22 +08:00
if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
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;
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
// If no system root was given, default to '/'
Filename.insert(Filename.begin(), '/');
return;
}
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
unsigned Length = isysroot.size();
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
if (isysroot[Length - 1] != '/')
Filename.insert(Filename.begin(), '/');
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
Filename.insert(Filename.begin(), isysroot.begin(), isysroot.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
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::ASTReadResult
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadASTBlock(Module &F) {
First baby steps towards PCHReader being able to keep track of multiple PCH files. WIP llvm-svn: 108537
2010-07-17 01:50:48 +08:00
llvm::BitstreamCursor &Stream = F.Stream;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
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
return Failure;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// Read all of the records and blocks for the ASt file.
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
bool First = true;
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +08:00
while (!Stream.AtEndOfStream()) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
unsigned Code = Stream.ReadCode();
if (Code == llvm::bitc::END_BLOCK) {
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
if (Stream.ReadBlockEnd()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("error at end of module block in AST file");
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
return Failure;
}
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
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
return Success;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +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
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +08:00
switch (Stream.ReadSubBlockID()) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECLTYPES_BLOCK_ID:
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
// We lazily load the decls block, but we want to set up the
// DeclsCursor cursor to point into it. Clone our current bitcode
// cursor to it, enter the block and read the abbrevs in that block.
// With the main cursor, we just skip over it.
First baby steps towards PCHReader being able to keep track of multiple PCH files. WIP llvm-svn: 108537
2010-07-17 01:50:48 +08:00
F.DeclsCursor = Stream;
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
if (Stream.SkipBlock() || // Skip with the main cursor.
// Read the abbrevs.
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
Set up DeclsCursor. llvm-svn: 70173
2009-04-27 09:05:14 +08:00
return Failure;
}
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +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
case DECL_UPDATES_BLOCK_ID:
if (Stream.SkipBlock()) {
Error("malformed block record in AST file");
return Failure;
}
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PREPROCESSOR_BLOCK_ID:
First baby steps towards PCHReader being able to keep track of multiple PCH files. WIP llvm-svn: 108537
2010-07-17 01:50:48 +08:00
F.MacroCursor = Stream;
Teach Preprocessor::macro_begin/macro_end to lazily load all macro definitions from a precompiled header. This ensures that code-completion with macro names behaves the same with or without precompiled headers. llvm-svn: 92497
2010-01-05 03:18:44 +08:00
if (PP)
PP->setExternalSource(this);
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
if (Stream.SkipBlock() ||
ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
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
return Failure;
}
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
F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
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
break;
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
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
case PREPROCESSOR_DETAIL_BLOCK_ID:
F.PreprocessorDetailCursor = Stream;
if (Stream.SkipBlock() ||
ReadBlockAbbrevs(F.PreprocessorDetailCursor,
PREPROCESSOR_DETAIL_BLOCK_ID)) {
Error("malformed preprocessor detail record in AST file");
return Failure;
}
F.PreprocessorDetailStartOffset
= F.PreprocessorDetailCursor.GetCurrentBitNo();
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SOURCE_MANAGER_BLOCK_ID:
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
switch (ReadSourceManagerBlock(F)) {
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +08:00
case Success:
break;
case Failure:
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed source manager block in AST file");
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
return Failure;
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +08:00
case IgnorePCH:
return IgnorePCH;
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
}
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +08:00
break;
}
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
First = 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
continue;
}
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +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
if (Code == llvm::bitc::DEFINE_ABBREV) {
Stream.ReadAbbrevRecord();
continue;
}
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +08:00
// Read and process a 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.clear();
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
const char *BlobStart = 0;
unsigned BlobLen = 0;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
&BlobStart, &BlobLen)) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
default: // Default behavior: ignore.
break;
Various minor fixes to PCH reading and writing, with general cleanup. Aside from a minor tweak to the PCH file format, no functionality change. llvm-svn: 68793
2009-04-11 01:25:41 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case METADATA: {
if (Record[0] != VERSION_MAJOR && !DisableValidation) {
Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
: diag::warn_pch_version_too_new);
return IgnorePCH;
}
RelocatablePCH = Record[4];
if (Listener) {
std::string TargetTriple(BlobStart, BlobLen);
if (Listener->ReadTargetTriple(TargetTriple))
return IgnorePCH;
}
break;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case CHAINED_METADATA: {
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
if (!First) {
Error("CHAINED_METADATA is not first record in block");
return Failure;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (Record[0] != VERSION_MAJOR && !DisableValidation) {
Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
: diag::warn_pch_version_too_new);
return IgnorePCH;
}
Give every file that ASTReader loads a type: module, PCH, precompiled preamble or main file. Base Decls' PCHLevel on this to make it more sane. llvm-svn: 115626
2010-10-06 00:15:19 +08:00
// Load the chained file, which is always a PCH file.
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
// FIXME: This could end up being a module.
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
switch(ReadASTCore(StringRef(BlobStart, BlobLen), MK_PCH)) {
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
case Failure: return Failure;
// If we have to ignore the dependency, we'll have to ignore this too.
case IgnorePCH: return IgnorePCH;
case Success: break;
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
}
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
break;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_OFFSET:
Promote DeclOffsets and TypeOffsets to per-file data. llvm-svn: 108760
2010-07-20 06:06:55 +08:00
if (F.LocalNumTypes != 0) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("duplicate TYPE_OFFSET record in AST file");
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
return Failure;
}
Promote DeclOffsets and TypeOffsets to per-file data. llvm-svn: 108760
2010-07-20 06:06:55 +08:00
F.TypeOffsets = (const uint32_t *)BlobStart;
F.LocalNumTypes = Record[0];
Continuing to improve and generalize how IDs are handled in ASTReader. This patch cleans up and generalizes TypeID loading and uses a similar table-lookup to Doug's previous Decl patch. llvm-svn: 135622
2011-07-21 05:31:32 +08:00
// Introduce the global -> local mapping for types within this
// AST file.
GlobalTypeMap.insert(std::make_pair(getTotalNumTypes() + 1,
std::make_pair(&F,
-getTotalNumTypes())));
TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OFFSET:
Promote DeclOffsets and TypeOffsets to per-file data. llvm-svn: 108760
2010-07-20 06:06:55 +08:00
if (F.LocalNumDecls != 0) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("duplicate DECL_OFFSET record in AST file");
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
return Failure;
}
Promote DeclOffsets and TypeOffsets to per-file data. llvm-svn: 108760
2010-07-20 06:06:55 +08:00
F.DeclOffsets = (const uint32_t *)BlobStart;
F.LocalNumDecls = Record[0];
Use a ContinuousRangeMap to map from the global declaration ID in the AST reader down to the AST file + local ID within that file, rather than lamely walking the PCH chain. There's no actual functionality change now, but this is cleaner and more general. llvm-svn: 135548
2011-07-20 08:27:43 +08:00
// Introduce the global -> local mapping for declarations within this
Use a ContinuousRangeMap to map from the global identifier ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135551
2011-07-20 08:59:32 +08:00
// AST file.
Use a ContinuousRangeMap to map from the global declaration ID in the AST reader down to the AST file + local ID within that file, rather than lamely walking the PCH chain. There's no actual functionality change now, but this is cleaner and more general. llvm-svn: 135548
2011-07-20 08:27:43 +08:00
GlobalDeclMap.insert(std::make_pair(getTotalNumDecls() + 1,
std::make_pair(&F,
-getTotalNumDecls())));
Use a ContinuousRangeMap to map from the global identifier ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135551
2011-07-20 08:59:32 +08:00
DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TU_UPDATE_LEXICAL: {
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
DeclContextInfo Info = {
Clean up the rest of the local -> global declaration ID mappings within the ASTReader (I hope). llvm-svn: 135720
2011-07-22 07:29:11 +08:00
&F,
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
/* No visible information */ 0,
Allow deserialization of just the fields of a record, when we want to iterate over them, instead of deserializing the complete declaration context of the record. Iterating over the fields of a record is very common (e.g to determine the layout), unfortunately we needlessly deserialize every declaration that the declaration context of the record contains; this can be bad for large C++ classes that contain a lot of methods. Fix this by allow deserialization of just the fields when we want to iterate over them. Progress for rdar://7260160. llvm-svn: 116507
2010-10-15 04:14:34 +08:00
reinterpret_cast<const KindDeclIDPair *>(BlobStart),
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
static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair))
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
};
If we get a TU_CONTEXT update from a chained PCH file before we actually have an ASTContext, delay the processing of that update. Patch by Sebastian Redl! Fixes <rdar://problem/8499034>. llvm-svn: 115263
2010-10-01 09:18:02 +08:00
DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0]
.push_back(Info);
Update the list of lexical decls in the TU for chained PCHs. This makes -ast-print show the decls from the dependent PCH. llvm-svn: 109524
2010-07-28 02:24:41 +08:00
break;
}
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
case UPDATE_VISIBLE: {
serialization::DeclID ID = Record[0];
void *Table = ASTDeclContextNameLookupTable::Create(
(const unsigned char *)BlobStart + Record[1],
(const unsigned char *)BlobStart,
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
ASTDeclContextNameLookupTrait(*this, F));
If we get a TU_CONTEXT update from a chained PCH file before we actually have an ASTContext, delay the processing of that update. Patch by Sebastian Redl! Fixes <rdar://problem/8499034>. llvm-svn: 115263
2010-10-01 09:18:02 +08:00
if (ID == 1 && Context) { // Is it the TU?
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
DeclContextInfo Info = {
Clean up the rest of the local -> global declaration ID mappings within the ASTReader (I hope). llvm-svn: 135720
2011-07-22 07:29:11 +08:00
&F, Table, /* No lexical inforamtion */ 0, 0
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
};
DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info);
} else
PendingVisibleUpdates[ID].push_back(Table);
break;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case REDECLS_UPDATE_LATEST: {
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(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
for (unsigned i = 0, e = Record.size(); i < e; i += 2) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
DeclID First = Record[i], Latest = Record[i+1];
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((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() ||
Latest > FirstLatestDeclIDs[First]) &&
"The new latest is supposed to come after the previous latest");
FirstLatestDeclIDs[First] = Latest;
}
break;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case LANGUAGE_OPTIONS:
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
if (ParseLanguageOptions(Record) && !DisableValidation)
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
return IgnorePCH;
break;
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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case IDENTIFIER_TABLE:
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
F.IdentifierTableData = BlobStart;
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
if (Record[0]) {
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
F.IdentifierLookupTable
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
= ASTIdentifierLookupTable::Create(
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
(const unsigned char *)F.IdentifierTableData + Record[0],
(const unsigned char *)F.IdentifierTableData,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ASTIdentifierLookupTrait(*this, F));
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
if (PP) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PP->getIdentifierTable().setExternalIdentifierLookup(this);
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
PP->getHeaderSearchInfo().SetExternalLookup(this);
}
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
}
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case IDENTIFIER_OFFSET:
Promote IdentifierOffsets to per-file data. llvm-svn: 108762
2010-07-20 06:28:42 +08:00
if (F.LocalNumIdentifiers != 0) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("duplicate IDENTIFIER_OFFSET record in 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
return Failure;
}
Promote IdentifierOffsets to per-file data. llvm-svn: 108762
2010-07-20 06:28:42 +08:00
F.IdentifierOffsets = (const uint32_t *)BlobStart;
F.LocalNumIdentifiers = Record[0];
Use a ContinuousRangeMap to map from the global identifier ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135551
2011-07-20 08:59:32 +08:00
// Introduce the global -> local mapping for identifiers within this AST
// file
GlobalIdentifierMap.insert(
std::make_pair(getTotalNumIdentifiers() + 1,
std::make_pair(&F,
-getTotalNumIdentifiers())));
IdentifiersLoaded.resize(IdentifiersLoaded.size() +F.LocalNumIdentifiers);
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
break;
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case EXTERNAL_DEFINITIONS:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
break;
Keep track of the number of statements/expressions written to and read from a PCH file. It turns out that "Hello, World!" is bringing in 19% of all of the statements in Carbon.h, so we need to be lazy. llvm-svn: 69393
2009-04-18 06:13:46 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SPECIAL_TYPES:
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case STATISTICS:
More work on getting PCHReader to handle multiple files. Promote SLocOffsets to per-file data. WIP llvm-svn: 108930
2010-07-21 05:20:32 +08:00
TotalNumStatements += Record[0];
TotalNumMacros += Record[1];
TotalLexicalDeclContexts += Record[2];
TotalVisibleDeclContexts += Record[3];
Keep track of the number of statements/expressions written to and read from a PCH file. It turns out that "Hello, World!" is bringing in 19% of all of the statements in Carbon.h, so we need to be lazy. llvm-svn: 69393
2009-04-18 06:13:46 +08:00
break;
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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case UNUSED_FILESCOPED_DECLS:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
Implementing unused function warning. llvm-svn: 95940
2010-02-12 08:07:30 +08:00
break;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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
case DELEGATING_CTORS:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case WEAK_UNDECLARED_IDENTIFIERS:
Make Sema::WeakUndeclaredIdentifiers lazily deserialized. llvm-svn: 136368
2011-07-29 02:09:57 +08:00
if (Record.size() % 4 != 0) {
Error("invalid weak identifiers record");
return Failure;
}
// FIXME: Ignore weak undeclared identifiers from non-original PCH
// files. This isn't the way to do it :)
WeakUndeclaredIdentifiers.clear();
// Translate the weak, undeclared identifiers into global IDs.
for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
WeakUndeclaredIdentifiers.push_back(
getGlobalIdentifierID(F, Record[I++]));
WeakUndeclaredIdentifiers.push_back(
getGlobalIdentifierID(F, Record[I++]));
WeakUndeclaredIdentifiers.push_back(
ReadSourceLocation(F, Record, I).getRawEncoding());
WeakUndeclaredIdentifiers.push_back(Record[I++]);
}
Support #pragma weak for PCH. llvm-svn: 110323
2010-08-05 17:48:08 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case LOCALLY_SCOPED_EXTERNAL_DECLS:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
break;
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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SELECTOR_OFFSETS:
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
F.SelectorOffsets = (const uint32_t *)BlobStart;
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
F.LocalNumSelectors = Record[0];
Use a ContinuousRangeMap to map from the global selector ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135554
2011-07-20 09:10:58 +08:00
// Introduce the global -> local mapping for identifiers within this AST
// file
GlobalSelectorMap.insert(
std::make_pair(getTotalNumSelectors() + 1,
std::make_pair(&F,
-getTotalNumSelectors())));
SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case METHOD_POOL:
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
F.SelectorLookupTableData = (const unsigned char *)BlobStart;
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
if (Record[0])
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
F.SelectorLookupTable
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
= ASTSelectorLookupTable::Create(
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
F.SelectorLookupTableData + Record[0],
F.SelectorLookupTableData,
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ASTSelectorLookupTrait(*this, F));
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
TotalNumMethodPoolEntries += Record[1];
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
break;
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
Only preload SLocEntries after the entire PCH chain was loaded. llvm-svn: 114518
2010-09-22 08:42:30 +08:00
case REFERENCED_SELECTOR_POOL:
Move a Module's ReferencedSelectorsData into the ASTReader itself, so that it accumulates referenced selectors from each of the modules/PCH files as they are loaded. No actual functionality change, yet. llvm-svn: 136356
2011-07-28 22:41:43 +08:00
if (!Record.empty()) {
for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
Record[Idx++]));
ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
getRawEncoding());
}
}
PCH read/write for selector reference pool. Finishes off radar 6507158. llvm-svn: 109256
2010-07-24 03:11:11 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PP_COUNTER_VALUE:
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (!Record.empty() && Listener)
Listener->ReadCounter(Record[0]);
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
break;
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
case SOURCE_LOCATION_OFFSETS: {
F.SLocEntryOffsets = (const uint32_t *)BlobStart;
More work on getting PCHReader to handle multiple files. Promote SLocOffsets to per-file data. WIP llvm-svn: 108930
2010-07-21 05:20:32 +08:00
F.LocalNumSLocEntries = Record[0];
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]);
// Make our entry in the range map. BaseID is negative and growing, so
// we invert it. Because we invert it, though, we need the other end of
// the range.
unsigned RangeStart =
unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
// Initialize the remapping table.
// Invalid stays invalid.
F.SLocRemap.insert(std::make_pair(0U, 0));
// This module. Base was 2 when being compiled.
F.SLocRemap.insert(std::make_pair(2U,
static_cast<int>(F.SLocEntryBaseOffset - 2)));
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
TotalNumSLocEntries += F.LocalNumSLocEntries;
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
break;
}
case SOURCE_LOCATION_MAP: {
// Additional remapping information.
const unsigned char *Data = (const unsigned char*)BlobStart;
const unsigned char *DataEnd = Data + BlobLen;
while(Data < DataEnd) {
uint32_t Offset = io::ReadUnalignedLE32(Data);
uint16_t Len = io::ReadUnalignedLE16(Data);
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 = StringRef((const char*)Data, Len);
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
Module *OM = ModuleMgr.lookup(Name);
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 (!OM) {
Error("SourceLocation remap refers to unknown module");
return Failure;
}
// My Offset is mapped to OM->SLocEntryBaseOffset.
F.SLocRemap.insert(std::make_pair(Offset,
static_cast<int>(OM->SLocEntryBaseOffset - Offset)));
Data += Len;
}
break;
}
case SOURCE_MANAGER_LINE_TABLE:
if (ParseLineTable(F, Record))
return Failure;
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
break;
[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
case FILE_SOURCE_LOCATION_OFFSETS:
F.SLocFileOffsets = (const uint32_t *)BlobStart;
F.LocalNumSLocFileEntries = Record[0];
break;
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
case SOURCE_LOCATION_PRELOADS: {
// Need to transform from the local view (1-based IDs) to the global view,
// which is based off F.SLocEntryBaseID.
PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size());
for (unsigned I = 0, N = Record.size(); I != N; ++I)
PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID);
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
break;
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
}
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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case STAT_CACHE: {
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
if (!DisableStatCache) {
ASTStatCache *MyStatCache =
new ASTStatCache((const unsigned char *)BlobStart + Record[0],
(const unsigned char *)BlobStart,
NumStatHits, NumStatMisses);
FileMgr.addStatCache(MyStatCache);
F.StatCache = MyStatCache;
}
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
break;
Add support for a chain of stat caches in the FileManager, rather than only supporting a single stat cache. The immediate benefit of this change is that we can now generate a PCH/AST file when including another PCH file; in the future, the chain of stat caches will likely be useful with multiple levels of PCH files. llvm-svn: 84263
2009-10-17 02:18:30 +08:00
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case EXT_VECTOR_DECLS:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case VTABLE_USES:
Lazily deserialize Sema::VTableUses. Plus, fix the utterly and completely broken deserialization mapping code we had for VTableUses, which would have broken horribly as soon as our local-to-global ID mapping became interesting. llvm-svn: 136371
2011-07-29 03:11:31 +08:00
if (Record.size() % 3 != 0) {
Error("Invalid VTABLE_USES record");
return Failure;
}
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Later tables overwrite earlier ones.
Lazily deserialize Sema::VTableUses. Plus, fix the utterly and completely broken deserialization mapping code we had for VTableUses, which would have broken horribly as soon as our local-to-global ID mapping became interesting. llvm-svn: 136371
2011-07-29 03:11:31 +08:00
// FIXME: Modules will have some trouble with this. This is clearly not
// the right way to do this.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
VTableUses.clear();
Lazily deserialize Sema::VTableUses. Plus, fix the utterly and completely broken deserialization mapping code we had for VTableUses, which would have broken horribly as soon as our local-to-global ID mapping became interesting. llvm-svn: 136371
2011-07-29 03:11:31 +08:00
for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
VTableUses.push_back(
ReadSourceLocation(F, Record, Idx).getRawEncoding());
VTableUses.push_back(Record[Idx++]);
}
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DYNAMIC_CLASSES:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PENDING_IMPLICIT_INSTANTIATIONS:
Promote the deserialized PendingInstantiations vector from being a Module member to being an ASTReader member; we want it to be centralized for lazy deserialization. llvm-svn: 136373
2011-07-29 03:26:52 +08:00
if (PendingInstantiations.size() % 2 != 0) {
Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
return Failure;
}
// Later lists of pending instantiations overwrite earlier ones.
// FIXME: This is most certainly wrong for modules.
PendingInstantiations.clear();
for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
PendingInstantiations.push_back(
ReadSourceLocation(F, Record, I).getRawEncoding());
}
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case SEMA_DECL_REFS:
Write various C++-specific records to chained PCHs. Tests will come later. llvm-svn: 110357
2010-08-06 02:21:25 +08:00
// Later tables overwrite earlier ones.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
// FIXME: Modules will have some trouble with this.
SemaDeclRefs.clear();
for (unsigned I = 0, N = Record.size(); I != N; ++I)
SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
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
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case ORIGINAL_FILE_NAME:
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// The primary AST will be the last to get here, so it will be the one
More work on getting PCHReader to handle multiple files. Promote SLocOffsets to per-file data. WIP llvm-svn: 108930
2010-07-21 05:20:32 +08:00
// that's used.
Redo how PCH handles its implicit include. Instead of treating this specially in the front-end (as far as the preprocessor goes), follow the usual logic of inserting the (original include path) name into the predefines buffer. This pushes the responsibility for handling this to PCH instead of the front-end. In PCH this requires being a little more clever when we diff the predefines buffers. Neither of these solutions are particularly great, I think what we eventually should do is something like gcc where we insert a special marker to indicate the PCH file, but then run the preprocessor as usual. This would be clearer and would allow us to drop the overly clever predefines handling. llvm-svn: 86806
2009-11-11 13:29:04 +08:00
ActualOriginalFileName.assign(BlobStart, BlobLen);
OriginalFileName = ActualOriginalFileName;
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
MaybeAddSystemRootToFilename(OriginalFileName);
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
break;
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
case ORIGINAL_FILE_ID:
OriginalFileID = FileID::get(Record[0]);
break;
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
case ORIGINAL_PCH_DIR:
// The primary AST will be the last to get here, so it will be the one
// that's used.
OriginalDir.assign(BlobStart, BlobLen);
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case VERSION_CONTROL_BRANCH_REVISION: {
Fix bug I introduced with assinging a temporary to a StringRef. llvm-svn: 96041
2010-02-13 07:31:14 +08:00
const std::string &CurBranch = getClangFullRepositoryVersion();
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 ASTBranch(BlobStart, BlobLen);
if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
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
return IgnorePCH;
}
break;
}
Promote some macro-related stuff to per-file data. Fix a cache-inefficient nested loop by inverting the nesting. Store the size of each file in the chain; will need this later for statement offsets. llvm-svn: 109030
2010-07-22 04:07:32 +08:00
Rework the detailed preprocessing record to separate preprocessing entities generated directly by the preprocessor from those loaded from the external source (e.g., the ASTReader). By separating these two sets of entities into different vectors, we allow both to grow independently, and eliminate the need for preallocating all of the loaded preprocessing entities. This is similar to the way the recent SourceManager refactoring treats FileIDs and the source location address space. As part of this, switch over to building a continuous range map to track preprocessing entities. llvm-svn: 135646
2011-07-21 08:47:40 +08:00
case MACRO_DEFINITION_OFFSETS: {
Promote some macro-related stuff to per-file data. Fix a cache-inefficient nested loop by inverting the nesting. Store the size of each file in the chain; will need this later for statement offsets. llvm-svn: 109030
2010-07-22 04:07:32 +08:00
F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
F.NumPreallocatedPreprocessingEntities = Record[0];
F.LocalNumMacroDefinitions = Record[1];
Rework the detailed preprocessing record to separate preprocessing entities generated directly by the preprocessor from those loaded from the external source (e.g., the ASTReader). By separating these two sets of entities into different vectors, we allow both to grow independently, and eliminate the need for preallocating all of the loaded preprocessing entities. This is similar to the way the recent SourceManager refactoring treats FileIDs and the source location address space. As part of this, switch over to building a continuous range map to track preprocessing entities. llvm-svn: 135646
2011-07-21 08:47:40 +08:00
// Introduce the global -> local mapping for preprocessed entities within
// this AST file.
unsigned StartingID;
if (PP) {
if (!PP->getPreprocessingRecord())
PP->createPreprocessingRecord(true);
if (!PP->getPreprocessingRecord()->getExternalSource())
PP->getPreprocessingRecord()->SetExternalSource(*this);
StartingID
= PP->getPreprocessingRecord()
->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities);
} else {
// FIXME: We'll eventually want to kill this path, since it assumes
// a particular allocation strategy in the preprocessing record.
StartingID = getTotalNumPreprocessedEntities();
}
GlobalPreprocessedEntityMap.insert(
std::make_pair(StartingID,
std::make_pair(&F, -(int)StartingID)));
// Introduce the global -> local mapping for macro definitions within
// this AST file.
Use a ContinuousRangeMap to map from the global macro definition ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. More cleanup/generalization, although there is more work to do for preprocessed entities. In particular, the "preallocation" scheme for preprocessed entities is not going to work well with late loading of PCH files, and it's likely we'll have to do something akin to the SourceManager's negative/positive loading. llvm-svn: 135556
2011-07-20 09:29:15 +08:00
GlobalMacroDefinitionMap.insert(
std::make_pair(getTotalNumMacroDefinitions() + 1,
std::make_pair(&F,
-getTotalNumMacroDefinitions())));
MacroDefinitionsLoaded.resize(
MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions);
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
break;
Rework the detailed preprocessing record to separate preprocessing entities generated directly by the preprocessor from those loaded from the external source (e.g., the ASTReader). By separating these two sets of entities into different vectors, we allow both to grow independently, and eliminate the need for preallocating all of the loaded preprocessing entities. This is similar to the way the recent SourceManager refactoring treats FileIDs and the source location address space. As part of this, switch over to building a continuous range map to track preprocessing entities. llvm-svn: 135646
2011-07-21 08:47:40 +08:00
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
case DECL_UPDATE_OFFSETS: {
if (Record.size() % 2 != 0) {
Error("invalid DECL_UPDATE_OFFSETS block in AST file");
return Failure;
}
for (unsigned I = 0, N = Record.size(); I != N; I += 2)
DeclUpdateOffsets[static_cast<DeclID>(Record[I])]
.push_back(std::make_pair(&F, Record[I+1]));
break;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_REPLACEMENTS: {
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 (Record.size() % 2 != 0) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("invalid DECL_REPLACEMENTS block in AST file");
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
return Failure;
}
for (unsigned I = 0, N = Record.size(); I != N; I += 2)
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
ReplacedDecls[static_cast<DeclID>(Record[I])] =
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
std::make_pair(&F, Record[I+1]);
break;
}
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
case CXX_BASE_SPECIFIER_OFFSETS: {
if (F.LocalNumCXXBaseSpecifiers != 0) {
Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
return Failure;
}
F.LocalNumCXXBaseSpecifiers = Record[0];
F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
Cleaning up more of the ID situation in the AST reader. This patch relaxes and generalizes how CXX base specifiers are identified and loaded by using a ContinuousRangeMap. This also adds a global bit offset (or base) to the PerFileData. llvm-svn: 135705
2011-07-22 05:15:19 +08:00
GlobalCXXBaseSpecifiersMap.insert(std::make_pair(
getTotalNumCXXBaseSpecifiers() + 1,
std::make_pair(&F,
-getTotalNumCXXBaseSpecifiers())));
NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
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
break;
}
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
case DIAG_PRAGMA_MAPPINGS:
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
if (Record.size() % 2 != 0) {
Error("invalid DIAG_USER_MAPPINGS block in AST file");
return Failure;
}
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 (F.PragmaDiagMappings.empty())
F.PragmaDiagMappings.swap(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
else
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
F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
Record.begin(), Record.end());
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
break;
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
AST, Sema, Serialization: keep track of cudaConfigureCall llvm-svn: 125216
2011-02-10 05:04:32 +08:00
case CUDA_SPECIAL_DECL_REFS:
// Later tables overwrite earlier ones.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
// FIXME: Modules will have trouble with this.
CUDASpecialDeclRefs.clear();
for (unsigned I = 0, N = Record.size(); I != N; ++I)
CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
AST, Sema, Serialization: keep track of cudaConfigureCall llvm-svn: 125216
2011-02-10 05:04:32 +08:00
break;
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
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
case 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
F.HeaderFileInfoTableData = BlobStart;
F.LocalNumHeaderFileInfos = Record[1];
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
F.HeaderFileFrameworkStrings = BlobStart + Record[2];
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
if (Record[0]) {
F.HeaderFileInfoTable
= HeaderFileInfoLookupTable::Create(
(const unsigned char *)F.HeaderFileInfoTableData + Record[0],
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
(const unsigned char *)F.HeaderFileInfoTableData,
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
HeaderFileInfoTrait(*this, F,
PP? &PP->getHeaderSearchInfo() : 0,
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
BlobStart + Record[2]));
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
if (PP)
PP->getHeaderSearchInfo().SetExternalSource(this);
}
break;
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
}
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
case FP_PRAGMA_OPTIONS:
// Later tables overwrite earlier ones.
FPPragmaOptions.swap(Record);
break;
case OPENCL_EXTENSIONS:
// Later tables overwrite earlier ones.
OpenCLExtensions.swap(Record);
break;
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
case TENTATIVE_DEFINITIONS:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
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
break;
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
case KNOWN_NAMESPACES:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
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
break;
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
}
Promote the identifier table to per-file data. Also, if a CHAINED_METADATA record exists, it has to be the first thing in the PCH file. llvm-svn: 108748
2010-07-20 04:52:06 +08:00
First = 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
}
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("premature end of bitstream in AST file");
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
return Failure;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
[PCH] Be conservative and check all the files the PCH references to see if a file was modified since the time the PCH was created. The parser is not fit to deal with stale PCHs, too many invariants do not hold up. rdar://9530587. llvm-svn: 132389
2011-06-01 13:43:53 +08:00
ASTReader::ASTReadResult ASTReader::validateFileEntries() {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator I = ModuleMgr.begin(),
E = ModuleMgr.end(); I != E; ++I) {
Module *F = *I;
[PCH] Be conservative and check all the files the PCH references to see if a file was modified since the time the PCH was created. The parser is not fit to deal with stale PCHs, too many invariants do not hold up. rdar://9530587. llvm-svn: 132389
2011-06-01 13:43:53 +08:00
llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
[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
for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) {
SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]);
[PCH] Be conservative and check all the files the PCH references to see if a file was modified since the time the PCH was created. The parser is not fit to deal with stale PCHs, too many invariants do not hold up. rdar://9530587. llvm-svn: 132389
2011-06-01 13:43:53 +08:00
unsigned Code = SLocEntryCursor.ReadCode();
if (Code == llvm::bitc::END_BLOCK ||
Code == llvm::bitc::ENTER_SUBBLOCK ||
Code == llvm::bitc::DEFINE_ABBREV) {
Error("incorrectly-formatted source location entry in AST file");
return Failure;
}
RecordData Record;
const char *BlobStart;
unsigned BlobLen;
switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
default:
Error("incorrectly-formatted source location entry in AST file");
return Failure;
case SM_SLOC_FILE_ENTRY: {
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(BlobStart, BlobLen);
[PCH] Be conservative and check all the files the PCH references to see if a file was modified since the time the PCH was created. The parser is not fit to deal with stale PCHs, too many invariants do not hold up. rdar://9530587. llvm-svn: 132389
2011-06-01 13:43:53 +08:00
const FileEntry *File = getFileEntry(Filename);
if (File == 0) {
std::string ErrorStr = "could not find file '";
ErrorStr += Filename;
ErrorStr += "' referenced by AST file";
Error(ErrorStr.c_str());
return IgnorePCH;
}
if (Record.size() < 6) {
Error("source location entry is incorrect");
return Failure;
}
// The stat info from the FileEntry came from the cached stat
// info of the PCH, so we cannot trust it.
struct stat StatBuf;
if (::stat(File->getName(), &StatBuf) != 0) {
StatBuf.st_size = File->getSize();
StatBuf.st_mtime = File->getModificationTime();
}
if (((off_t)Record[4] != StatBuf.st_size
#if !defined(LLVM_ON_WIN32)
// In our regression testing, the Windows file system seems to
// have inconsistent modification times that sometimes
// erroneously trigger this error-handling path.
|| (time_t)Record[5] != StatBuf.st_mtime
#endif
)) {
Error(diag::err_fe_pch_file_modified, Filename);
return IgnorePCH;
}
break;
}
}
}
}
return Success;
}
Give every file that ASTReader loads a type: module, PCH, precompiled preamble or main file. Base Decls' PCHLevel on this to make it more sane. llvm-svn: 115626
2010-10-06 00:15:19 +08:00
ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ModuleKind Type) {
Give every file that ASTReader loads a type: module, PCH, precompiled preamble or main file. Base Decls' PCHLevel on this to make it more sane. llvm-svn: 115626
2010-10-06 00:15:19 +08:00
switch(ReadASTCore(FileName, Type)) {
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +08:00
case Failure: return Failure;
case IgnorePCH: return IgnorePCH;
case Success: break;
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10: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
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
// Here comes stuff that we only do once the entire chain is loaded.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[PCH] Be conservative and check all the files the PCH references to see if a file was modified since the time the PCH was created. The parser is not fit to deal with stale PCHs, too many invariants do not hold up. rdar://9530587. llvm-svn: 132389
2011-06-01 13:43:53 +08:00
if (!DisableValidation) {
switch(validateFileEntries()) {
case Failure: return Failure;
case IgnorePCH: return IgnorePCH;
case Success: break;
}
}
Only preload SLocEntries after the entire PCH chain was loaded. llvm-svn: 114518
2010-09-22 08:42:30 +08:00
// Preload SLocEntries.
for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
if (Result != Success)
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
return Failure;
Only preload SLocEntries after the entire PCH chain was loaded. llvm-svn: 114518
2010-09-22 08:42:30 +08:00
}
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
PreloadSLocEntries.clear();
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +08:00
// Check the predefines buffers.
Modules don't require validation of the predefines buffer llvm-svn: 136224
2011-07-28 00:30:06 +08:00
if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers())
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
return IgnorePCH;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (PP) {
Fix a comment. llvm-svn: 76303
2009-07-18 17:26:51 +08:00
// Initialization of keywords and pragmas occurs before the
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// AST file is read, so there may be some identifiers that were
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// loaded into the IdentifierTable before we intercepted the
// creation of identifiers. Iterate through the list of known
// identifiers and determine whether we have to establish
// preprocessor definitions or top-level identifier declaration
// chains for those identifiers.
//
// We copy the IdentifierInfo pointers to a small vector first,
// since de-serializing declarations or macro definitions can add
// new entries into the identifier table, invalidating the
// iterators.
Modules don't require validation of the predefines buffer llvm-svn: 136224
2011-07-28 00:30:06 +08:00
//
// FIXME: We need a lazier way to load this information, e.g., by marking
// the identifier data as 'dirty', so that it will be looked up in the
// AST file(s) if it is uttered in the source. This could save us some
// module load time.
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<IdentifierInfo *, 128> Identifiers;
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
IdEnd = PP->getIdentifierTable().end();
Id != IdEnd; ++Id)
Identifiers.push_back(Id->second);
Promote some macro-related stuff to per-file data. Fix a cache-inefficient nested loop by inverting the nesting. Store the size of each file in the chain; will need this later for statement offsets. llvm-svn: 109030
2010-07-22 04:07:32 +08:00
// We need to search the tables in all files.
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator J = ModuleMgr.begin(),
M = ModuleMgr.end(); J != M; ++J) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTIdentifierLookupTable *IdTable
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
= (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable;
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// Not all AST files necessarily have identifier tables, only the useful
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
// ones.
if (!IdTable)
continue;
Promote some macro-related stuff to per-file data. Fix a cache-inefficient nested loop by inverting the nesting. Store the size of each file in the chain; will need this later for statement offsets. llvm-svn: 109030
2010-07-22 04:07:32 +08:00
for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
IdentifierInfo *II = Identifiers[I];
// Look in the on-disk hash tables for an entry for this identifier
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
ASTIdentifierLookupTrait Info(*this, *(*J), II);
Promote some macro-related stuff to per-file data. Fix a cache-inefficient nested loop by inverting the nesting. Store the size of each file in the chain; will need this later for statement offsets. llvm-svn: 109030
2010-07-22 04:07:32 +08:00
std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
More work on getting PCHReader to handle multiple files. Promote SLocOffsets to per-file data. WIP llvm-svn: 108930
2010-07-21 05:20:32 +08:00
if (Pos == IdTable->end())
continue;
// Dereferencing the iterator has the effect of populating the
// IdentifierInfo node with the various declarations it needs.
(void)*Pos;
}
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +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
}
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (Context)
InitializeContext(*Context);
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
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 (DeserializationListener)
DeserializationListener->ReaderInitialized(this);
When loading a precompiled preamble, use the file ID of the precompiled preamble as the "main" source file's file ID within the source manager. This makes compiling with a precompiled preamble produce the same source locations as when compiling without the precompiled preamble; prior to this change, we ended up with different file IDs for source locations within the precompiled preamble vs. those after the precompiled preamble, even for entities (e.g., preprocessing entities) in the same file. llvm-svn: 120390
2010-11-30 13:23:00 +08:00
// If this AST file is a precompiled preamble, then set the main file ID of
// the source manager to the file source file from which the preamble was
// built. This is the only valid way to use a precompiled preamble.
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
if (Type == MK_Preamble) {
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
if (OriginalFileID.isInvalid()) {
SourceLocation Loc
= SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
if (Loc.isValid())
OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
When loading a precompiled preamble, use the file ID of the precompiled preamble as the "main" source file's file ID within the source manager. This makes compiling with a precompiled preamble produce the same source locations as when compiling without the precompiled preamble; prior to this change, we ended up with different file IDs for source locations within the precompiled preamble vs. those after the precompiled preamble, even for entities (e.g., preprocessing entities) in the same file. llvm-svn: 120390
2010-11-30 13:23:00 +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
else {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
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
+ OriginalFileID.getOpaqueValue() - 1);
}
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
if (!OriginalFileID.isInvalid())
SourceMgr.SetPreambleFileID(OriginalFileID);
When loading a precompiled preamble, use the file ID of the precompiled preamble as the "main" source file's file ID within the source manager. This makes compiling with a precompiled preamble produce the same source locations as when compiling without the precompiled preamble; prior to this change, we ended up with different file IDs for source locations within the precompiled preamble vs. those after the precompiled preamble, even for entities (e.g., preprocessing entities) in the same file. llvm-svn: 120390
2010-11-30 13:23:00 +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
return Success;
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
}
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
ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ModuleKind Type) {
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
Module &F = ModuleMgr.addModule(FileName, Type);
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +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
if (FileName != "-") {
CurrentDir = llvm::sys::path::parent_path(FileName);
if (CurrentDir.empty()) CurrentDir = ".";
}
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
if (!ASTBuffers.empty()) {
The ASTReader created by -chain-include used the generated PCH buffers in the wrong order. The effect was that all but the first chain-include files was ignored for subsequent compilations. llvm-svn: 129513
2011-04-14 22:07:41 +08:00
F.Buffer.reset(ASTBuffers.back());
ASTBuffers.pop_back();
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
assert(F.Buffer && "Passed null buffer");
} else {
// Open the AST file.
//
// FIXME: This shouldn't be here, we should just take a raw_ostream.
std::string ErrStr;
llvm::error_code ec;
if (FileName == "-") {
ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
if (ec)
ErrStr = ec.message();
} else
F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
if (!F.Buffer) {
Error(ErrStr.c_str());
return IgnorePCH;
}
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +08:00
}
// Initialize the stream
F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
(const unsigned char *)F.Buffer->getBufferEnd());
llvm::BitstreamCursor &Stream = F.Stream;
Stream.init(F.StreamFile);
Promote some macro-related stuff to per-file data. Fix a cache-inefficient nested loop by inverting the nesting. Store the size of each file in the chain; will need this later for statement offsets. llvm-svn: 109030
2010-07-22 04:07:32 +08:00
F.SizeInBits = F.Buffer->getBufferSize() * 8;
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
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +08:00
// Sniff for the signature.
if (Stream.Read(8) != 'C' ||
Stream.Read(8) != 'P' ||
Stream.Read(8) != 'C' ||
Stream.Read(8) != 'H') {
Diag(diag::err_not_a_pch_file) << FileName;
return Failure;
}
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
while (!Stream.AtEndOfStream()) {
unsigned Code = Stream.ReadCode();
if (Code != llvm::bitc::ENTER_SUBBLOCK) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("invalid record at top-level of AST file");
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
return Failure;
}
unsigned BlockID = Stream.ReadSubBlockID();
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// We only know the AST subblock ID.
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
switch (BlockID) {
case llvm::bitc::BLOCKINFO_BLOCK_ID:
if (Stream.ReadBlockInfoBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed BlockInfoBlock in AST file");
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
return Failure;
}
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case AST_BLOCK_ID:
Rename various classes from PCH to AST. llvm-svn: 111471
2010-08-19 07:56:56 +08:00
switch (ReadASTBlock(F)) {
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
case Success:
break;
case Failure:
return Failure;
case IgnorePCH:
// FIXME: We could consider reading through to the end of this
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// AST block, skipping subblocks, to see if there are other
// AST blocks elsewhere.
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +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
// FIXME: We can't clear loaded slocentries anymore.
//SourceMgr.ClearPreallocatedSLocEntries();
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
// Remove the stat cache.
if (F.StatCache)
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
return IgnorePCH;
}
break;
default:
if (Stream.SkipBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("malformed block record in AST file");
Teach the PCH reader to load the dependency when encountering a chain metadata record. WIP llvm-svn: 108578
2010-07-17 08:12:06 +08:00
return Failure;
}
break;
}
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +08:00
}
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
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
// Once read, set the Module bit base offset and update the size in
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
// bits of all files we've seen.
F.GlobalBitOffset = TotalModulesSizeInBits;
TotalModulesSizeInBits += F.SizeInBits;
GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
Separate out the initial loading of a PCH so that loading chained PCHs can reuse it. llvm-svn: 108551
2010-07-17 04:41:52 +08:00
return Success;
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::setPreprocessor(Preprocessor &pp) {
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
PP = &pp;
Rework the detailed preprocessing record to separate preprocessing entities generated directly by the preprocessor from those loaded from the external source (e.g., the ASTReader). By separating these two sets of entities into different vectors, we allow both to grow independently, and eliminate the need for preallocating all of the loaded preprocessing entities. This is similar to the way the recent SourceManager refactoring treats FileIDs and the source location address space. As part of this, switch over to building a continuous range map to track preprocessing entities. llvm-svn: 135646
2011-07-21 08:47:40 +08:00
if (unsigned N = getTotalNumPreprocessedEntities()) {
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 (!PP->getPreprocessingRecord())
Introduce a new libclang parsing flag, CXTranslationUnit_NestedMacroInstantiations, which indicates whether we want to see "nested" macro instantiations (e.g., those that occur inside other macro instantiations) within the detailed preprocessing record. Many clients (e.g., those that only care about visible tokens) don't care about this information, and in code that uses preprocessor metaprogramming, this information can have a very high cost. Addresses <rdar://problem/9389320>. llvm-svn: 130990
2011-05-07 00:33:08 +08:00
PP->createPreprocessingRecord(true);
Rework the detailed preprocessing record to separate preprocessing entities generated directly by the preprocessor from those loaded from the external source (e.g., the ASTReader). By separating these two sets of entities into different vectors, we allow both to grow independently, and eliminate the need for preallocating all of the loaded preprocessing entities. This is similar to the way the recent SourceManager refactoring treats FileIDs and the source location address space. As part of this, switch over to building a continuous range map to track preprocessing entities. llvm-svn: 135646
2011-07-21 08:47:40 +08:00
PP->getPreprocessingRecord()->SetExternalSource(*this);
PP->getPreprocessingRecord()->allocateLoadedEntities(N);
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
}
Rework the detailed preprocessing record to separate preprocessing entities generated directly by the preprocessor from those loaded from the external source (e.g., the ASTReader). By separating these two sets of entities into different vectors, we allow both to grow independently, and eliminate the need for preallocating all of the loaded preprocessing entities. This is similar to the way the recent SourceManager refactoring treats FileIDs and the source location address space. As part of this, switch over to building a continuous range map to track preprocessing entities. llvm-svn: 135646
2011-07-21 08:47:40 +08:00
PP->getHeaderSearchInfo().SetExternalLookup(this);
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
PP->getHeaderSearchInfo().SetExternalSource(this);
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
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::InitializeContext(ASTContext &Ctx) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context = &Ctx;
assert(Context && "Passed null context!");
assert(PP && "Forgot to set Preprocessor ?");
PP->getIdentifierTable().setExternalIdentifierLookup(this);
Teach Preprocessor::macro_begin/macro_end to lazily load all macro definitions from a precompiled header. This ensures that code-completion with macro names behaves the same with or without precompiled headers. llvm-svn: 92497
2010-01-05 03:18:44 +08:00
PP->setExternalSource(this);
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
If we get a TU_CONTEXT update from a chained PCH file before we actually have an ASTContext, delay the processing of that update. Patch by Sebastian Redl! Fixes <rdar://problem/8499034>. llvm-svn: 115263
2010-10-01 09:18:02 +08:00
// If we have an update block for the TU waiting, we have to add it before
// deserializing the decl.
DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
if (DCU != DeclContextOffsets.end()) {
// Insertion could invalidate map, so grab vector.
DeclContextInfos T;
T.swap(DCU->second);
DeclContextOffsets.erase(DCU);
DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T);
}
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// Load the translation unit declaration
Introduce PCHReader::GetTranslationUnitDecl() and use it instead of ReadDeclRecord when initializing. ReadDeclRecord would hit assertion if the translation unit declaration was already loaded during IdentifierInfo initialization. llvm-svn: 107885
2010-07-09 01:13:02 +08:00
GetTranslationUnitDecl();
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
// Load the special types.
Context->setBuiltinVaListType(
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID])
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context->setObjCIdType(GetType(Id));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR])
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context->setObjCSelType(GetType(Sel));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL])
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context->setObjCProtoType(GetType(Proto));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS])
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context->setObjCClassType(GetType(Class));
This patch includes a conceptually simple, but very intrusive/pervasive change. The idea is to segregate Objective-C "object" pointers from general C pointers (utilizing the recently added ObjCObjectPointerType). The fun starts in Sema::GetTypeForDeclarator(), where "SomeInterface *" is now represented by a single AST node (rather than a PointerType whose Pointee is an ObjCInterfaceType). Since a significant amount of code assumed ObjC object pointers where based on C pointers/structs, this patch is very tedious. It should also explain why it is hard to accomplish this in smaller, self-contained patches. This patch does most of the "heavy lifting" related to moving from PointerType->ObjCObjectPointerType. It doesn't include all potential "cleanups". The good news is additional cleanups can be done later (some are noted in the code). This patch is so large that I didn't want to include any changes that are purely aesthetic. By making the ObjC types truly built-in, they are much easier to work with (and require fewer "hacks"). For example, there is no need for ASTContext::isObjCIdStructType() or ASTContext::isObjCClassStructType()! We believe this change (and the follow-up cleanups) will pay dividends over time. Given the amount of code change, I do expect some fallout from this change (though it does pass all of the clang tests). If you notice any problems, please let us know asap! Thanks. llvm-svn: 75314
2009-07-11 07:34:53 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING])
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context->setCFConstantStringType(GetType(String));
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (unsigned FastEnum
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
= SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
Context->setObjCFastEnumerationStateType(GetType(FastEnum));
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
Make ASTContext explicitly keep track of the declaration for the C FILE type, rather than using name lookup to find FILE within the translation unit. Within precompiled headers, FILE is treated as yet another "special type" (like __builtin_va_list). This change should provide a performance improvement (not verified), since the lookup into the translation unit declaration forces the (otherwise unneeded) construction of a large hash table. More importantly, with precompiled headers, the construction of that table requires deserializing most of the top-level declarations from the precompiled header, which are then unused. Fixes PR 4509. llvm-svn: 74911
2009-07-08 00:35:42 +08:00
QualType FileType = GetType(File);
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (FileType.isNull()) {
Error("FILE type is NULL");
return;
}
Change all the Type::getAsFoo() methods to specializations of Type::getAs(). Several of the existing methods were identical to their respective specializations, and so have been removed entirely. Several more 'leaf' optimizations were introduced. The getAsFoo() methods which imposed extra conditions, like getAsObjCInterfacePointerType(), have been left in place. llvm-svn: 82501
2009-09-22 07:43:11 +08:00
if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
Make ASTContext explicitly keep track of the declaration for the C FILE type, rather than using name lookup to find FILE within the translation unit. Within precompiled headers, FILE is treated as yet another "special type" (like __builtin_va_list). This change should provide a performance improvement (not verified), since the lookup into the translation unit declaration forces the (otherwise unneeded) construction of a large hash table. More importantly, with precompiled headers, the construction of that table requires deserializing most of the top-level declarations from the precompiled header, which are then unused. Fixes PR 4509. llvm-svn: 74911
2009-07-08 00:35:42 +08:00
Context->setFILEDecl(Typedef->getDecl());
else {
Change uses of: Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsRecordType() -> Type::getAs<RecordType>() Type::getAsPointerType() -> Type::getAs<PointerType>() Type::getAsBlockPointerType() -> Type::getAs<BlockPointerType>() Type::getAsLValueReferenceType() -> Type::getAs<LValueReferenceType>() Type::getAsRValueReferenceType() -> Type::getAs<RValueReferenceType>() Type::getAsMemberPointerType() -> Type::getAs<MemberPointerType>() Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsTagType() -> Type::getAs<TagType>() And remove Type::getAsReferenceType(), etc. This change is similar to one I made a couple weeks ago, but that was partly reverted pending some additional design discussion. With Doug's pending smart pointer changes for Types, it seemed natural to take this approach. llvm-svn: 77510
2009-07-30 05:53:49 +08:00
const TagType *Tag = FileType->getAs<TagType>();
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (!Tag) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("Invalid FILE type in AST file");
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
return;
}
Make ASTContext explicitly keep track of the declaration for the C FILE type, rather than using name lookup to find FILE within the translation unit. Within precompiled headers, FILE is treated as yet another "special type" (like __builtin_va_list). This change should provide a performance improvement (not verified), since the lookup into the translation unit declaration forces the (otherwise unneeded) construction of a large hash table. More importantly, with precompiled headers, the construction of that table requires deserializing most of the top-level declarations from the precompiled header, which are then unused. Fixes PR 4509. llvm-svn: 74911
2009-07-08 00:35:42 +08:00
Context->setFILEDecl(Tag->getDecl());
}
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
QualType Jmp_bufType = GetType(Jmp_buf);
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Jmp_bufType.isNull()) {
Error("jmp_bug type is NULL");
return;
}
Change all the Type::getAsFoo() methods to specializations of Type::getAs(). Several of the existing methods were identical to their respective specializations, and so have been removed entirely. Several more 'leaf' optimizations were introduced. The getAsFoo() methods which imposed extra conditions, like getAsObjCInterfacePointerType(), have been left in place. llvm-svn: 82501
2009-09-22 07:43:11 +08:00
if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
Context->setjmp_bufDecl(Typedef->getDecl());
else {
Change uses of: Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsRecordType() -> Type::getAs<RecordType>() Type::getAsPointerType() -> Type::getAs<PointerType>() Type::getAsBlockPointerType() -> Type::getAs<BlockPointerType>() Type::getAsLValueReferenceType() -> Type::getAs<LValueReferenceType>() Type::getAsRValueReferenceType() -> Type::getAs<RValueReferenceType>() Type::getAsMemberPointerType() -> Type::getAs<MemberPointerType>() Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsTagType() -> Type::getAs<TagType>() And remove Type::getAsReferenceType(), etc. This change is similar to one I made a couple weeks ago, but that was partly reverted pending some additional design discussion. With Doug's pending smart pointer changes for Types, it seemed natural to take this approach. llvm-svn: 77510
2009-07-30 05:53:49 +08:00
const TagType *Tag = Jmp_bufType->getAs<TagType>();
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (!Tag) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("Invalid jmp_buf type in AST file");
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
return;
}
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
Context->setjmp_bufDecl(Tag->getDecl());
}
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
QualType Sigjmp_bufType = GetType(Sigjmp_buf);
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Sigjmp_bufType.isNull()) {
Error("sigjmp_buf type is NULL");
return;
}
Change all the Type::getAsFoo() methods to specializations of Type::getAs(). Several of the existing methods were identical to their respective specializations, and so have been removed entirely. Several more 'leaf' optimizations were introduced. The getAsFoo() methods which imposed extra conditions, like getAsObjCInterfacePointerType(), have been left in place. llvm-svn: 82501
2009-09-22 07:43:11 +08:00
if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
Context->setsigjmp_bufDecl(Typedef->getDecl());
else {
Change uses of: Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsRecordType() -> Type::getAs<RecordType>() Type::getAsPointerType() -> Type::getAs<PointerType>() Type::getAsBlockPointerType() -> Type::getAs<BlockPointerType>() Type::getAsLValueReferenceType() -> Type::getAs<LValueReferenceType>() Type::getAsRValueReferenceType() -> Type::getAs<RValueReferenceType>() Type::getAsMemberPointerType() -> Type::getAs<MemberPointerType>() Type::getAsReferenceType() -> Type::getAs<ReferenceType>() Type::getAsTagType() -> Type::getAs<TagType>() And remove Type::getAsReferenceType(), etc. This change is similar to one I made a couple weeks ago, but that was partly reverted pending some additional design discussion. With Doug's pending smart pointer changes for Types, it seemed natural to take this approach. llvm-svn: 77510
2009-07-30 05:53:49 +08:00
const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
assert(Tag && "Invalid sigjmp_buf type in AST file");
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
Context->setsigjmp_bufDecl(Tag->getDecl());
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (unsigned ObjCIdRedef
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
= SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION])
Make the new Objective-C "id" and "Class" redefinition types special types that are preloaded by the PCH file. Fixes PCH breakage introduced in r79248. llvm-svn: 79583
2009-08-21 08:27:50 +08:00
Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (unsigned ObjCClassRedef
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
= SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
Make the new Objective-C "id" and "Class" redefinition types special types that are preloaded by the PCH file. Fixes PCH breakage introduced in r79248. llvm-svn: 79583
2009-08-21 08:27:50 +08:00
Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR])
Refine the type of the first parameter to block invoke functions. WIP. I have yet to find the magic incantation to get the structure type to be defined. If someone has a pointer, love to hear it. llvm-svn: 84590
2009-10-20 10:12:22 +08:00
Context->setBlockDescriptorType(GetType(String));
Extend out the block descriptor structure for debug information with the copy/dispose helpers as appropriate. llvm-svn: 84817
2009-10-22 08:49:09 +08:00
if (unsigned String
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
= SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
Extend out the block descriptor structure for debug information with the copy/dispose helpers as appropriate. llvm-svn: 84817
2009-10-22 08:49:09 +08:00
Context->setBlockDescriptorExtendedType(GetType(String));
More work toward implementing NeXt's -fno-constant-cfstrings - wip. llvm-svn: 102189
2010-04-24 01:41:07 +08:00
if (unsigned ObjCSelRedef
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
= SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
More work toward implementing NeXt's -fno-constant-cfstrings - wip. llvm-svn: 102189
2010-04-24 01:41:07 +08:00
Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING])
More work toward implementing NeXt's -fno-constant-cfstrings - wip. llvm-svn: 102189
2010-04-24 01:41:07 +08:00
Context->setNSConstantStringType(GetType(String));
Don't try to install the __[u]int128_t identifier if it is already installed by PCHReader. Currently, adding it to visible decls of a PCH'ed translation unit has no effect because adding visible decls before deserialization has no effect (the decls won't be visible). This will be fixed in a future commit; then it will force deserialization of visible decls, so avoid pointlessly installing it. llvm-svn: 107595
2010-07-05 05:44:19 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
Don't try to install the __[u]int128_t identifier if it is already installed by PCHReader. Currently, adding it to visible decls of a PCH'ed translation unit has no effect because adding visible decls before deserialization has no effect (the decls won't be visible). This will be fixed in a future commit; then it will force deserialization of visible decls, so avoid pointlessly installing it. llvm-svn: 107595
2010-07-05 05:44:19 +08:00
Context->setInt128Installed();
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
Add support for C++0x's range-based for loops, as specified by the C++11 draft standard (N3291). llvm-svn: 129541
2011-04-15 06:09:26 +08:00
if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
Context->AutoDeductTy = GetType(AutoDeduct);
if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
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
ReadPragmaDiagnosticMappings(Context->getDiagnostics());
AST, Sema, Serialization: keep track of cudaConfigureCall llvm-svn: 125216
2011-02-10 05:04:32 +08:00
// If there were any CUDA special declarations, deserialize them.
if (!CUDASpecialDeclRefs.empty()) {
assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
Context->setcudaConfigureCallDecl(
cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
}
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
}
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
/// \brief Retrieve the name of the original source file name
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
/// directly from the AST file, without actually loading the AST
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
/// file.
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
FileManager &FileMgr,
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
Diagnostic &Diags) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// Open the AST file.
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
std::string ErrStr;
llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
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
if (!Buffer) {
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
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
return std::string();
}
// Initialize the stream
llvm::BitstreamReader StreamFile;
llvm::BitstreamCursor Stream;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
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
(const unsigned char *)Buffer->getBufferEnd());
Stream.init(StreamFile);
// Sniff for the signature.
if (Stream.Read(8) != 'C' ||
Stream.Read(8) != 'P' ||
Stream.Read(8) != 'C' ||
Stream.Read(8) != 'H') {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
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
return std::string();
}
RecordData Record;
while (!Stream.AtEndOfStream()) {
unsigned Code = Stream.ReadCode();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
unsigned BlockID = Stream.ReadSubBlockID();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// We only know the AST subblock 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
switch (BlockID) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case AST_BLOCK_ID:
if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
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
return std::string();
}
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
default:
if (Stream.SkipBlock()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
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
return std::string();
}
break;
}
continue;
}
if (Code == llvm::bitc::END_BLOCK) {
if (Stream.ReadBlockEnd()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
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
return std::string();
}
continue;
}
if (Code == llvm::bitc::DEFINE_ABBREV) {
Stream.ReadAbbrevRecord();
continue;
}
Record.clear();
const char *BlobStart = 0;
unsigned BlobLen = 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
== 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
return std::string(BlobStart, BlobLen);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
}
Make precompiled headers work with -E. When we're only preprocessing (with -E), we turn the PCH include into an implicit include of the file from which the PCH file was generated. llvm-svn: 71534
2009-05-12 09:31:05 +08:00
return std::string();
}
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
/// \brief Parse the record that corresponds to a LangOptions data
/// structure.
///
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
/// This routine parses the language options from the AST file and then gives
/// them to the AST listener if one is set.
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
///
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
/// \returns true if the listener deems the file unacceptable, false otherwise.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
bool ASTReader::ParseLanguageOptions(
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
const SmallVectorImpl<uint64_t> &Record) {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
if (Listener) {
LangOptions LangOpts;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
#define PARSE_LANGOPT(Option) \
LangOpts.Option = Record[Idx]; \
++Idx
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
unsigned Idx = 0;
PARSE_LANGOPT(Trigraphs);
PARSE_LANGOPT(BCPLComment);
PARSE_LANGOPT(DollarIdents);
PARSE_LANGOPT(AsmPreprocessor);
PARSE_LANGOPT(GNUMode);
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
PARSE_LANGOPT(GNUKeywords);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(ImplicitInt);
PARSE_LANGOPT(Digraphs);
PARSE_LANGOPT(HexFloats);
PARSE_LANGOPT(C99);
C1X: add a language standard llvm-svn: 129553
2011-04-15 08:35:23 +08:00
PARSE_LANGOPT(C1X);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(Microsoft);
PARSE_LANGOPT(CPlusPlus);
PARSE_LANGOPT(CPlusPlus0x);
PARSE_LANGOPT(CXXOperatorNames);
PARSE_LANGOPT(ObjC1);
PARSE_LANGOPT(ObjC2);
PARSE_LANGOPT(ObjCNonFragileABI);
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
PARSE_LANGOPT(ObjCNonFragileABI2);
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
PARSE_LANGOPT(AppleKext);
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
PARSE_LANGOPT(ObjCDefaultSynthProperties);
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
PARSE_LANGOPT(ObjCInferRelatedResultType);
Check for -fno-constant-cfstrings consistency in pch. llvm-svn: 102130
2010-04-23 05:01:59 +08:00
PARSE_LANGOPT(NoConstantCFStrings);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(PascalStrings);
PARSE_LANGOPT(WritableStrings);
PARSE_LANGOPT(LaxVectorConversions);
Write/Read new Language Options llvm-svn: 74221
2009-06-26 07:01:11 +08:00
PARSE_LANGOPT(AltiVec);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(Exceptions);
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
PARSE_LANGOPT(ObjCExceptions);
Add a CXXExceptions flag to LangOptions. llvm-svn: 126299
2011-02-23 11:04:54 +08:00
PARSE_LANGOPT(CXXExceptions);
PARSE_LANGOPT(SjLjExceptions);
Basic support for -mms-bitfields, from Carl Norum! llvm-svn: 124661
2011-02-01 23:15:22 +08:00
PARSE_LANGOPT(MSBitfields);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(NeXTRuntime);
PARSE_LANGOPT(Freestanding);
PARSE_LANGOPT(NoBuiltin);
PARSE_LANGOPT(ThreadsafeStatics);
Save/load POSIXThreads flag for PCH llvm-svn: 80916
2009-09-03 22:36:33 +08:00
PARSE_LANGOPT(POSIXThreads);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(Blocks);
PARSE_LANGOPT(EmitAllDecls);
PARSE_LANGOPT(MathErrno);
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
LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
Record[Idx++]);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(HeinousExtensions);
PARSE_LANGOPT(Optimize);
PARSE_LANGOPT(OptimizeSize);
PARSE_LANGOPT(Static);
PARSE_LANGOPT(PICLevel);
PARSE_LANGOPT(GNUInline);
PARSE_LANGOPT(NoInline);
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
PARSE_LANGOPT(Deprecated);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(AccessControl);
PARSE_LANGOPT(CharIsSigned);
Adding -fshort-wchar option. llvm-svn: 86167
2009-11-06 04:14:16 +08:00
PARSE_LANGOPT(ShortWChar);
Store/retrieve -fshort-enums for PCH, fixes rdar://8854933. llvm-svn: 123510
2011-01-15 10:56:16 +08:00
PARSE_LANGOPT(ShortEnums);
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
LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
Substantially revise how clang computes the visibility of a declaration to more closely parallel the computation of linkage. This gets us to a state much closer to what gcc emits, modulo bugs, which will undoubtedly arise in abundance. llvm-svn: 117147
2010-10-23 05:05:15 +08:00
LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
Add missing PCH support for -fstack-protector. llvm-svn: 82435
2009-09-21 12:16:19 +08:00
LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
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[Idx++]);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
PARSE_LANGOPT(InstantiationDepth);
Write/Read new Language Options llvm-svn: 74221
2009-06-26 07:01:11 +08:00
PARSE_LANGOPT(OpenCL);
Serialization: support for CUDA language extensions llvm-svn: 120588
2010-12-02 03:14:57 +08:00
PARSE_LANGOPT(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
PARSE_LANGOPT(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
PARSE_LANGOPT(DefaultFPContract);
Add missing options. llvm-svn: 126755
2011-03-02 01:36:40 +08:00
PARSE_LANGOPT(ElideConstructors);
PARSE_LANGOPT(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
PARSE_LANGOPT(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
PARSE_LANGOPT(ObjCAutoRefCount);
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
#undef PARSE_LANGOPT
return Listener->ReadLanguageOptions(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
}
return false;
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::ReadPreprocessedEntities() {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
Module &F = *(*I);
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 (!F.PreprocessorDetailCursor.getBitStreamReader())
continue;
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
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
F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
while (LoadPreprocessedEntity(F)) { }
}
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
}
Rename the operation that loads a preprocessed entity from a given offset to indicate that we're loading from an offset, not an index, lest one be confused. No functionality change. llvm-svn: 125394
2011-02-12 03:46:30 +08:00
PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
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
RecordLocation Loc = getLocalBitOffset(Offset);
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
// Keep track of where we are in the stream, then jump back there
// after reading this entity.
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
SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
return LoadPreprocessedEntity(*Loc.F);
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
}
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
HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
Module &F = *(*I);
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(),
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
F.HeaderFileFrameworkStrings,
FE->getName());
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
HeaderFileInfoLookupTable *Table
= static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
if (!Table)
continue;
// Look in the on-disk hash table for an entry for this file name.
HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
&Trait);
if (Pos == Table->end())
continue;
HeaderFileInfo HFI = *Pos;
if (Listener)
Listener->ReadHeaderFileInfo(HFI, FE->getUID());
return HFI;
}
return HeaderFileInfo();
}
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 ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
Module &F = *(*I);
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 Idx = 0;
while (Idx < F.PragmaDiagMappings.size()) {
SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
while (1) {
assert(Idx < F.PragmaDiagMappings.size() &&
"Invalid data, didn't find '-1' marking end of diag/map pairs");
if (Idx >= F.PragmaDiagMappings.size()) {
break; // Something is messed up but at least avoid infinite loop in
// release build.
}
unsigned DiagID = F.PragmaDiagMappings[Idx++];
if (DiagID == (unsigned)-1) {
break; // no more diag/map pairs for this location.
}
diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
Diag.setDiagnosticMapping(DiagID, Map, Loc);
}
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
}
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
}
}
Allow loading types from any file in the chain. WIP llvm-svn: 108954
2010-07-21 06:37:49 +08:00
/// \brief Get the correct cursor and offset for loading a type.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
Continuing to improve and generalize how IDs are handled in ASTReader. This patch cleans up and generalizes TypeID loading and uses a similar table-lookup to Doug's previous Decl patch. llvm-svn: 135622
2011-07-21 05:31:32 +08:00
GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index+1);
assert(I != GlobalTypeMap.end() && "Corrupted global type map");
return RecordLocation(I->second.first,
I->second.first->TypeOffsets[Index + I->second.second]);
Allow loading types from any file in the chain. WIP llvm-svn: 108954
2010-07-21 06:37:49 +08:00
}
/// \brief Read and return the type with the given index..
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
///
Allow loading types from any file in the chain. WIP llvm-svn: 108954
2010-07-21 06:37:49 +08:00
/// The index is the type ID, shifted and minus the number of predefs. This
/// routine actually reads the record corresponding to the type at the given
/// location. It is a helper routine for GetType, which deals with reading type
/// IDs.
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ASTReader::readTypeRecord(unsigned Index) {
Allow loading types from any file in the chain. WIP llvm-svn: 108954
2010-07-21 06:37:49 +08:00
RecordLocation Loc = TypeCursorForIndex(Index);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
First baby steps towards PCHReader being able to keep track of multiple PCH files. WIP llvm-svn: 108537
2010-07-17 01:50:48 +08:00
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
// Keep track of where we are in the stream, then jump back there
// after reading this type.
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
SavedStreamPosition SavedPosition(DeclsCursor);
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
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
ReadingKindTracker ReadingKind(Read_Type, *this);
Reintroduce the ASTConsumer/ASTUnit fix from r110610, it has nothing to do with the breakage. llvm-svn: 110840
2010-08-12 02:52:41 +08:00
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
// Note that we are loading a type record.
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
Deserializing AType(this);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
unsigned Idx = 0;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
DeclsCursor.JumpToBit(Loc.Offset);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
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
unsigned Code = DeclsCursor.ReadCode();
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
case TYPE_EXT_QUAL: {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Record.size() != 2) {
Error("Incorrect encoding of extended qualifier type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Base = readType(*Loc.F, Record, Idx);
Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
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
return Context->getQualifiedType(Base, Quals);
PCH support for ExtQualType llvm-svn: 69230
2009-04-16 06:00:08 +08:00
}
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_COMPLEX: {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Record.size() != 1) {
Error("Incorrect encoding of complex type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElemType = readType(*Loc.F, Record, Idx);
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getComplexType(ElemType);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
case TYPE_POINTER: {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Record.size() != 1) {
Error("Incorrect encoding of pointer type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType PointeeType = readType(*Loc.F, Record, Idx);
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getPointerType(PointeeType);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
case TYPE_BLOCK_POINTER: {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Record.size() != 1) {
Error("Incorrect encoding of block pointer type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType PointeeType = readType(*Loc.F, Record, Idx);
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getBlockPointerType(PointeeType);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
case TYPE_LVALUE_REFERENCE: {
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
if (Record.size() != 2) {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
Error("Incorrect encoding of lvalue reference type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType PointeeType = readType(*Loc.F, Record, Idx);
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
return Context->getLValueReferenceType(PointeeType, Record[1]);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
case TYPE_RVALUE_REFERENCE: {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
if (Record.size() != 1) {
Error("Incorrect encoding of rvalue reference type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType PointeeType = readType(*Loc.F, Record, Idx);
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getRValueReferenceType(PointeeType);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
case TYPE_MEMBER_POINTER: {
Fix broken reading of member pointer from PCH. llvm-svn: 107472
2010-07-02 19:55:15 +08:00
if (Record.size() != 2) {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
Error("Incorrect encoding of member pointer type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType PointeeType = readType(*Loc.F, Record, Idx);
QualType ClassType = readType(*Loc.F, Record, Idx);
Eliminate the branching in QualType::getTypePtr() by providing a common base for ExtQuals and Type that stores the underlying type pointer. This results in a 2% performance win for -emit-llvm on a typical C file, with 1% memory growth in the AST. Note that there is an API change in this optimization: QualType::getTypePtr() can no longer be invoked on a NULL QualType. If the QualType might be NULL, use QualType::getTypePtrOrNull(). I've audited all uses of getTypePtr() in the code base and changed the appropriate uses over to getTypePtrOrNull(). A future optimization opportunity would be to distinguish between cast/dyn_cast and cast_or_null/dyn_cast_or_null; for the former, we could use getTypePtr() rather than getTypePtrOrNull(), to take another branch out of the cast/dyn_cast implementation. llvm-svn: 121489
2010-12-11 01:03:06 +08:00
if (PointeeType.isNull() || ClassType.isNull())
return QualType();
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
case TYPE_CONSTANT_ARRAY: {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElementType = readType(*Loc.F, Record, Idx);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
unsigned Idx = 3;
llvm::APInt Size = ReadAPInt(Record, Idx);
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
return Context->getConstantArrayType(ElementType, Size,
ASM, IndexTypeQuals);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_INCOMPLETE_ARRAY: {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElementType = readType(*Loc.F, Record, Idx);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_VARIABLE_ARRAY: {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElementType = readType(*Loc.F, Record, Idx);
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
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
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
ASM, IndexTypeQuals,
SourceRange(LBLoc, RBLoc));
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_VECTOR: {
improve altivec vector bool/pixel support, patch by Anton Yartsev with several tweaks by me. llvm-svn: 106619
2010-06-23 14:00:24 +08:00
if (Record.size() != 3) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("incorrect encoding of vector type in AST file");
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElementType = readType(*Loc.F, Record, Idx);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
unsigned NumElements = Record[1];
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
unsigned VecKind = Record[2];
improve altivec vector bool/pixel support, patch by Anton Yartsev with several tweaks by me. llvm-svn: 106619
2010-06-23 14:00:24 +08:00
return Context->getVectorType(ElementType, NumElements,
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
(VectorType::VectorKind)VecKind);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_EXT_VECTOR: {
improve altivec vector bool/pixel support, patch by Anton Yartsev with several tweaks by me. llvm-svn: 106619
2010-06-23 14:00:24 +08:00
if (Record.size() != 3) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("incorrect encoding of extended vector type in AST file");
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElementType = readType(*Loc.F, Record, Idx);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
unsigned NumElements = Record[1];
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getExtVectorType(ElementType, NumElements);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_FUNCTION_NO_PROTO: {
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
if (Record.size() != 6) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("incorrect encoding of no-proto function type");
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ResultType = readType(*Loc.F, Record, Idx);
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
FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
(CallingConv)Record[4], Record[5]);
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
return Context->getFunctionNoProtoType(ResultType, Info);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_FUNCTION_PROTO: {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ResultType = readType(*Loc.F, Record, Idx);
Restore r121752 without modification. llvm-svn: 121763
2010-12-14 16:05:40 +08:00
FunctionProtoType::ExtProtoInfo EPI;
EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
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
/*hasregparm*/ Record[2],
/*regparm*/ Record[3],
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
static_cast<CallingConv>(Record[4]),
/*produces*/ Record[5]);
Restore r121752 without modification. llvm-svn: 121763
2010-12-14 16:05:40 +08:00
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
unsigned Idx = 6;
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
unsigned NumParams = Record[Idx++];
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<QualType, 16> ParamTypes;
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
for (unsigned I = 0; I != NumParams; ++I)
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
ParamTypes.push_back(readType(*Loc.F, Record, Idx));
Restore r121752 without modification. llvm-svn: 121763
2010-12-14 16:05:40 +08:00
EPI.Variadic = Record[Idx++];
EPI.TypeQuals = Record[Idx++];
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
EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
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
ExceptionSpecificationType EST =
static_cast<ExceptionSpecificationType>(Record[Idx++]);
EPI.ExceptionSpecType = EST;
if (EST == EST_Dynamic) {
EPI.NumExceptions = Record[Idx++];
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<QualType, 2> Exceptions;
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
for (unsigned I = 0; I != EPI.NumExceptions; ++I)
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Exceptions.push_back(readType(*Loc.F, Record, Idx));
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
EPI.Exceptions = Exceptions.data();
} else if (EST == EST_ComputedNoexcept) {
EPI.NoexceptExpr = ReadExpr(*Loc.F);
}
Use v.data() instead of &v[0] when SmallVector v might be empty. llvm-svn: 72210
2009-05-21 17:52:38 +08:00
return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
Restore r121752 without modification. llvm-svn: 121763
2010-12-14 16:05:40 +08:00
EPI);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
case TYPE_UNRESOLVED_USING: {
unsigned Idx = 0;
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
return Context->getTypeDeclType(
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_TYPEDEF: {
- 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
if (Record.size() != 2) {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
Error("incorrect encoding of typedef type");
return QualType();
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
unsigned Idx = 0;
TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Canonical = readType(*Loc.F, Record, Idx);
When de-serializing a type that is supposed to be canonical, call getCanonicalType() to make sure that the type we got back is actually canonical. This is the case for most types, which always build a canonical type when given canonical components. However, some types that involve expressions in their canonicalization (e.g., array types with dependent sizes) don't always build canonical types from canonical components, because there is no such thing as a "canonical" expression. Therefore, we do this extra mapping to ensure that the canonical types we store are actually canonical. llvm-svn: 117344
2010-10-26 08:51:02 +08:00
if (!Canonical.isNull())
Canonical = Context->getCanonicalType(Canonical);
- 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
return Context->getTypedefType(Decl, Canonical);
}
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_TYPEOF_EXPR:
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return Context->getTypeOfExprType(ReadExpr(*Loc.F));
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_TYPEOF: {
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
if (Record.size() != 1) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("incorrect encoding of typeof(type) in AST file");
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType UnderlyingType = readType(*Loc.F, Record, Idx);
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->getTypeOfType(UnderlyingType);
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
}
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
case TYPE_DECLTYPE:
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return Context->getDecltypeType(ReadExpr(*Loc.F));
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
case TYPE_UNARY_TRANSFORM: {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType BaseType = readType(*Loc.F, Record, Idx);
QualType UnderlyingType = readType(*Loc.F, Record, Idx);
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
UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
}
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
case TYPE_AUTO:
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
return Context->getAutoType(readType(*Loc.F, Record, Idx));
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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_RECORD: {
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
if (Record.size() != 2) {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
Error("incorrect encoding of record type");
return QualType();
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
unsigned Idx = 0;
bool IsDependent = Record[Idx++];
QualType T
= Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
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
return T;
}
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_ENUM: {
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
if (Record.size() != 2) {
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +08:00
Error("incorrect encoding of enum type");
return QualType();
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
unsigned Idx = 0;
bool IsDependent = Record[Idx++];
QualType T
= Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
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
return T;
}
Add PCH support for enumerations and enumerators. llvm-svn: 68974
2009-04-14 02:14:40 +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
case TYPE_ATTRIBUTED: {
if (Record.size() != 3) {
Error("incorrect encoding of attributed type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType modifiedType = readType(*Loc.F, Record, Idx);
QualType equivalentType = readType(*Loc.F, Record, Idx);
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
AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
return Context->getAttributedType(kind, modifiedType, equivalentType);
}
Added ParenType type node. llvm-svn: 121488
2010-12-11 00:29:40 +08:00
case TYPE_PAREN: {
if (Record.size() != 1) {
Error("incorrect encoding of paren type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType InnerType = readType(*Loc.F, Record, Idx);
Added ParenType type node. llvm-svn: 121488
2010-12-11 00:29:40 +08:00
return Context->getParenType(InnerType);
}
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
case TYPE_PACK_EXPANSION: {
Fix a thinko where I didn't update a consistency check for PackExpansionType in the AST reader. We need more testing for variadic templates + PCH, but this fixes PR9073. llvm-svn: 124662
2011-02-01 23:24:58 +08:00
if (Record.size() != 2) {
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
Error("incorrect encoding of pack expansion type");
return QualType();
}
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Pattern = readType(*Loc.F, Record, Idx);
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
if (Pattern.isNull())
return QualType();
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
llvm::Optional<unsigned> NumExpansions;
if (Record[1])
NumExpansions = Record[1] - 1;
return Context->getPackExpansionType(Pattern, NumExpansions);
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
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_ELABORATED: {
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType NamedType = readType(*Loc.F, Record, Idx);
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
return Context->getElaboratedType(Keyword, NNS, NamedType);
Basic support for representing elaborated type specifiers directly in the AST. The current thinking is to create these only in C++ mode for efficiency. But for now, they're not being created at all; patch to follow. This will let us do things like verify that tags match during template instantation, as well as signal that an elaborated type specifier was used for clients that actually care. Optimally, the TypeLoc hierarchy should be adjusted to carry tag location information as well. llvm-svn: 81057
2009-09-05 08:15:47 +08:00
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_OBJC_INTERFACE: {
deserialization support for qualified interfaces llvm-svn: 69782
2009-04-22 14:45:28 +08:00
unsigned Idx = 0;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ObjCInterfaceDecl *ItfD
= ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
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
return Context->getObjCInterfaceType(ItfD);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_OBJC_OBJECT: {
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
unsigned Idx = 0;
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Base = readType(*Loc.F, Record, Idx);
deserialization support for qualified interfaces llvm-svn: 69782
2009-04-22 14:45:28 +08:00
unsigned NumProtos = Record[Idx++];
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<ObjCProtocolDecl*, 4> Protos;
deserialization support for qualified interfaces llvm-svn: 69782
2009-04-22 14:45:28 +08:00
for (unsigned I = 0; I != NumProtos; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
deserialization support for qualified interfaces llvm-svn: 69782
2009-04-22 14:45:28 +08:00
}
Introduce PCH (de-)serialization for most compound types, excluding Objective-C types and record types for the moment. llvm-svn: 68984
2009-04-14 04:46:52 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_OBJC_OBJECT_POINTER: {
pch support for protocol qualified id's. llvm-svn: 69781
2009-04-22 14:40:03 +08:00
unsigned Idx = 0;
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Pointee = readType(*Loc.F, Record, Idx);
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
return Context->getObjCObjectPointerType(Pointee);
pch support for protocol qualified id's. llvm-svn: 69781
2009-04-22 14:40:03 +08:00
}
Introduce ObjCProtocolListType type subclass. This is used only for keeping detailed type source information for protocol references, it should not participate in the semantics of the type system. Its protocol list is not canonicalized. llvm-svn: 83093
2009-09-30 03:42:55 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case 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
unsigned Idx = 0;
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Parm = readType(*Loc.F, Record, Idx);
QualType Replacement = readType(*Loc.F, Record, Idx);
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
return
Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
Replacement);
}
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
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
case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
unsigned Idx = 0;
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Parm = readType(*Loc.F, Record, Idx);
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
TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
return Context->getSubstTemplateTypeParmPackType(
cast<TemplateTypeParmType>(Parm),
ArgPack);
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_INJECTED_CLASS_NAME: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
Allow reading of InjectedClassNameType from PCH even when its decl is currently initializing. llvm-svn: 107473
2010-07-02 19:55:20 +08:00
// FIXME: ASTContext::getInjectedClassNameType is not currently suitable
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// for AST reading, too much interdependencies.
Allow reading of InjectedClassNameType from PCH even when its decl is currently initializing. llvm-svn: 107473
2010-07-02 19:55:20 +08:00
return
QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
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
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_TEMPLATE_TYPE_PARM: {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
unsigned Idx = 0;
unsigned Depth = Record[Idx++];
unsigned Index = Record[Idx++];
bool Pack = Record[Idx++];
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
TemplateTypeParmDecl *D
= ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
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
return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_DEPENDENT_NAME: {
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Canon = readType(*Loc.F, Record, Idx);
When de-serializing a type that is supposed to be canonical, call getCanonicalType() to make sure that the type we got back is actually canonical. This is the case for most types, which always build a canonical type when given canonical components. However, some types that involve expressions in their canonicalization (e.g., array types with dependent sizes) don't always build canonical types from canonical components, because there is no such thing as a "canonical" expression. Therefore, we do this extra mapping to ensure that the canonical types we store are actually canonical. llvm-svn: 117344
2010-10-26 08:51:02 +08:00
if (!Canon.isNull())
Canon = Context->getCanonicalType(Canon);
Fix reading of DependentNameType. llvm-svn: 107474
2010-07-02 19:55:24 +08:00
return Context->getDependentNameType(Keyword, NNS, Name, Canon);
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
unsigned NumArgs = Record[Idx++];
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<TemplateArgument, 8> Args;
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
Args.reserve(NumArgs);
while (NumArgs--)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
Args.size(), Args.data());
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_DEPENDENT_SIZED_ARRAY: {
Support DependentSizedArrayType for PCH. llvm-svn: 107267
2010-06-30 16:49:25 +08:00
unsigned Idx = 0;
// ArrayType
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType ElementType = readType(*Loc.F, Record, Idx);
Support DependentSizedArrayType for PCH. llvm-svn: 107267
2010-06-30 16:49:25 +08:00
ArrayType::ArraySizeModifier ASM
= (ArrayType::ArraySizeModifier)Record[Idx++];
unsigned IndexTypeQuals = Record[Idx++];
// DependentSizedArrayType
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Expr *NumElts = ReadExpr(*Loc.F);
SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
Support DependentSizedArrayType for PCH. llvm-svn: 107267
2010-06-30 16:49:25 +08:00
return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
IndexTypeQuals, Brackets);
}
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case TYPE_TEMPLATE_SPECIALIZATION: {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
unsigned Idx = 0;
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
bool IsDependent = Record[Idx++];
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
TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
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<TemplateArgument, 8> Args;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType Underlying = readType(*Loc.F, Record, Idx);
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
QualType T;
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
if (Underlying.isNull())
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
T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
Args.size());
- 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
else
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
T = Context->getTemplateSpecializationType(Name, Args.data(),
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
Args.size(), Underlying);
Change QualType::getTypePtr() to return a const pointer, then change a thousand other things which were (generally inadvertantly) relying on that. llvm-svn: 123814
2011-01-19 14:33:43 +08:00
const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
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
return T;
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +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
}
// Suppress a GCC warning
return QualType();
}
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader &Reader;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F;
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
llvm::BitstreamCursor &DeclsCursor;
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
const ASTReader::RecordData &Record;
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
unsigned &Idx;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
unsigned &I) {
return Reader.ReadSourceLocation(F, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
template<typename T>
T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
return Reader.ReadDeclAs<T>(F, Record, Idx);
}
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
public:
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
TypeLocReader(ASTReader &Reader, Module &F,
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
const ASTReader::RecordData &Record, unsigned &Idx)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
: Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
{ }
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
// We want compile-time assurance that we've enumerated all of
// these, so unfortunately we have to declare them first, then
// define them out-of-line.
#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 VisitFunctionTypeLoc(FunctionTypeLoc);
void VisitArrayTypeLoc(ArrayTypeLoc);
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 TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc 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
// nothing to do
}
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 TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
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
if (TL.needsExtraLocalData()) {
TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
TL.setModeAttr(Record[Idx++]);
}
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 TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setStarLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setCaretLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setAmpLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setStarLoc(ReadSourceLocation(Record, Idx));
Improved MemberPointerType source locations. llvm-svn: 127085
2011-03-05 22:42:21 +08:00
TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
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 TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
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
if (Record[Idx++])
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setSizeExpr(Reader.ReadExpr(F));
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
else
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
TL.setSizeExpr(0);
}
void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocReader::VisitDependentSizedArrayTypeLoc(
DependentSizedArrayTypeLoc TL) {
VisitArrayTypeLoc(TL);
}
void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
DependentSizedExtVectorTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
Forgotten part of previous commit. llvm-svn: 127536
2011-03-12 19:17:06 +08:00
TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
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
TL.setTrailingReturn(Record[Idx++]);
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) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
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 TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
void TypeLocReader::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 TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +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 TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
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 TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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
}
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 TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
TL.setKWLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
}
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 TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
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 TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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
}
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 TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
if (TL.hasAttrOperand()) {
SourceRange range;
range.setBegin(ReadSourceLocation(Record, Idx));
range.setEnd(ReadSourceLocation(Record, Idx));
TL.setAttrOperandParensRange(range);
}
if (TL.hasAttrExprOperand()) {
if (Record[Idx++])
TL.setAttrExprOperand(Reader.ReadExpr(F));
else
TL.setAttrExprOperand(0);
} else if (TL.hasAttrEnumOperand())
TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
}
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 TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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
}
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 TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
SubstTemplateTypeParmTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
SubstTemplateTypeParmPackTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
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 TypeLocReader::VisitTemplateSpecializationTypeLoc(
TemplateSpecializationTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
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
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
TL.setArgLocInfo(i,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.GetTemplateArgumentLocInfo(F,
TL.getTypePtr()->getArg(i).getKind(),
Record, Idx));
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
}
Added ParenType type node. llvm-svn: 121488
2010-12-11 00:29:40 +08:00
void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
}
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
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
TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
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
}
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 TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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
}
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 TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
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
TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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
}
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 TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
DependentTemplateSpecializationTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
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
TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
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
for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
TL.setArgLocInfo(I,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.GetTemplateArgumentLocInfo(F,
TL.getTypePtr()->getArg(I).getKind(),
Record, Idx));
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 TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
}
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 TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setNameLoc(ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
TL.setHasBaseTypeAsWritten(Record[Idx++]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
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
for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
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 TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TL.setStarLoc(ReadSourceLocation(Record, Idx));
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
const RecordData &Record,
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
unsigned &Idx) {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType InfoTy = readType(F, Record, Idx);
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
if (InfoTy.isNull())
return 0;
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
TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TypeLocReader TLR(*this, F, Record, Idx);
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
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
TLR.Visit(TL);
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
return TInfo;
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 pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
QualType ASTReader::GetType(TypeID ID) {
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
unsigned FastQuals = ID & Qualifiers::FastMask;
unsigned Index = ID >> Qualifiers::FastWidth;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
if (Index < NUM_PREDEF_TYPE_IDS) {
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
QualType T;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
switch ((PredefinedTypeIDs)Index) {
case PREDEF_TYPE_NULL_ID: return QualType();
case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; 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
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PREDEF_TYPE_CHAR_U_ID:
case PREDEF_TYPE_CHAR_S_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
// FIXME: Check that the signedness of CharTy is correct!
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
T = Context->CharTy;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break;
case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break;
case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break;
case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break;
case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break;
case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break;
case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break;
case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break;
case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break;
case PREDEF_TYPE_INT_ID: T = Context->IntTy; break;
case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break;
case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break;
case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break;
case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break;
case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break;
case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break;
case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break;
Make yet another placeholder type, this one marking that an expression is a bound member function, i.e. something of the form 'x.f' where 'f' is a non-static member function. Diagnose this in the general case. Some of the new diagnostics are probably worse than the old ones, but we now get this right much more universally, and there's certainly room for improvement in the diagnostics. llvm-svn: 130239
2011-04-27 04:42:42 +08:00
case PREDEF_TYPE_BOUND_MEMBER: T = Context->BoundMemberTy; break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break;
Basic, untested implementation for an "unknown any" type requested by LLDB. The idea is that you can create a VarDecl with an unknown type, or a FunctionDecl with an unknown return type, and it will still be valid to access that object as long as you explicitly cast it at every use. I'm still going back and forth about how I want to test this effectively, but I wanted to go ahead and provide a skeletal implementation for the LLDB folks' benefit and because it also improves some diagnostic goodness for placeholder expressions. llvm-svn: 129065
2011-04-07 16:22:57 +08:00
case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break;
case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break;
case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break;
case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break;
case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break;
case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; 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
}
assert(!T.isNull() && "Unknown predefined type");
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
return T.withFastQualifiers(FastQuals);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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
Index -= NUM_PREDEF_TYPE_IDS;
Allow loading types from any file in the chain. WIP llvm-svn: 108954
2010-07-21 06:37:49 +08:00
assert(Index < TypesLoaded.size() && "Type index out-of-range");
Increase the max PCH level for declarations to 7. Add a FromPCH flag to types. llvm-svn: 108354
2010-07-15 04:26:45 +08:00
if (TypesLoaded[Index].isNull()) {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
TypesLoaded[Index] = readTypeRecord(Index);
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
if (TypesLoaded[Index].isNull())
return QualType();
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
TypesLoaded[Index]->setFromAST();
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
TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(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
if (DeserializationListener)
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
DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
TypesLoaded[Index]);
Increase the max PCH level for declarations to 7. Add a FromPCH flag to types. llvm-svn: 108354
2010-07-15 04:26:45 +08:00
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
return TypesLoaded[Index].withFastQualifiers(FastQuals);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
return GetType(getGlobalTypeID(F, LocalID));
}
serialization::TypeID
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
// FIXME: Map from local type ID to global type ID.
return LocalID;
}
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 ASTReader::GetTypeID(QualType T) const {
return MakeTypeID(T,
std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
}
TypeIdx ASTReader::GetTypeIdx(QualType T) const {
if (T.isNull())
return TypeIdx();
assert(!T.getLocalFastQualifiers());
TypeIdxMap::const_iterator I = TypeIdxs.find(T);
// GetTypeIdx is mostly used for computing the hash of DeclarationNames and
// comparing keys of ASTDeclContextNameLookupTable.
// If the type didn't come from the AST file use a specially marked index
// so that any hash/key comparison fail since no such index is stored
// in a AST file.
if (I == TypeIdxs.end())
return TypeIdx(-1);
return I->second;
}
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
TemplateArgumentLocInfo
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::GetTemplateArgumentLocInfo(Module &F,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TemplateArgument::ArgKind 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
const RecordData &Record,
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
unsigned &Index) {
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
switch (Kind) {
case TemplateArgument::Expression:
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return ReadExpr(F);
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::Type:
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return GetTypeSourceInfo(F, Record, Index);
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
NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
Index);
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
SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
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
return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
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
SourceLocation());
}
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
NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
Index);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
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
SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
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
return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
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
EllipsisLoc);
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
}
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:
return TemplateArgumentLocInfo();
}
Un-namespace-qualify llvm_unreachable. It's a macro, so the qualification gave no extra safety anyway. llvm-svn: 91207
2009-12-12 13:05:38 +08:00
llvm_unreachable("unexpected template argument loc");
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
return TemplateArgumentLocInfo();
}
-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
TemplateArgumentLoc
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadTemplateArgumentLoc(Module &F,
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
const RecordData &Record, unsigned &Index) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
if (Arg.getKind() == TemplateArgument::Expression) {
if (Record[Index++]) // bool InfoHasSameExpr.
return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
}
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
Record, Index));
-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
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
Decl *ASTReader::GetExternalDecl(uint32_t ID) {
Alter the ExternalASTSource interface to permit by-name lookups. PCH continues to bring in the entire lookup table at once. Also, give ExternalSemaSource's vtable a home. This is important because otherwise any reference to it will cause RTTI to be emitted, and since clang is compiled with -fno-rtti, that RTTI will contain unresolved references (to ExternalASTSource's RTTI). So this change makes it possible to subclass ExternalSemaSource from projects compiled with RTTI, as long as the subclass's home is compiled with -fno-rtti. llvm-svn: 105268
2010-06-01 17:23:16 +08:00
return GetDecl(ID);
}
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
uint64_t
ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
if (ID == 0)
return 0;
When deserializing CXXBaseSpecifiers (and offsets), make sure to walk the chain in the correct order. llvm-svn: 127315
2011-03-09 13:09:32 +08:00
Cleaning up more of the ID situation in the AST reader. This patch relaxes and generalizes how CXX base specifiers are identified and loaded by using a ContinuousRangeMap. This also adds a global bit offset (or base) to the PerFileData. llvm-svn: 135705
2011-07-22 05:15:19 +08:00
GlobalCXXBaseSpecifiersMapType::iterator I =
GlobalCXXBaseSpecifiersMap.find(ID);
assert (I != GlobalCXXBaseSpecifiersMap.end() &&
"Corrupted global CXX base specifiers map");
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
Cleaning up more of the ID situation in the AST reader. This patch relaxes and generalizes how CXX base specifiers are identified and loaded by using a ContinuousRangeMap. This also adds a global bit offset (or base) to the PerFileData. llvm-svn: 135705
2011-07-22 05:15:19 +08:00
return I->second.first->CXXBaseSpecifiersOffsets[ID - 1 +
I->second.second] +
I->second.first->GlobalBitOffset;
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
}
CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
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
RecordLocation Loc = getLocalBitOffset(Offset);
llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
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
SavedStreamPosition SavedPosition(Cursor);
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
Cursor.JumpToBit(Loc.Offset);
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
ReadingKindTracker ReadingKind(Read_Decl, *this);
RecordData Record;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.ReadRecord(Code, Record);
if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
Error("Malformed AST file: missing C++ base specifiers");
return 0;
}
unsigned Idx = 0;
unsigned NumBases = Record[Idx++];
void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
for (unsigned I = 0; I != NumBases; ++I)
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
Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
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
return Bases;
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
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
if (!DeclsLoaded[0]) {
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
ReadDeclRecord(0, 1);
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
if (DeserializationListener)
Add a little more data to chained PCHs. WIP llvm-svn: 108528
2010-07-17 00:36:56 +08:00
DeserializationListener->DeclRead(1, DeclsLoaded[0]);
Add a callback interface that allows interested parties to get notified whenever PCHReader deserializes a type or decl (and possibly other things in the future). Have PCHWriter implement these callbacks as noops and register to receive them if we're chaining PCHs. This will allow PCHWriter to track the IDs of these things, which it needs to write the dependent files. WIP llvm-svn: 108383
2010-07-15 07:45:08 +08:00
}
Introduce PCHReader::GetTranslationUnitDecl() and use it instead of ReadDeclRecord when initializing. ReadDeclRecord would hit assertion if the translation unit declaration was already loaded during IdentifierInfo initialization. llvm-svn: 107885
2010-07-09 01:13:02 +08:00
return cast<TranslationUnitDecl>(DeclsLoaded[0]);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
serialization::DeclID
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
// FIXME: Perform local -> global remapping for declarations.
return LocalID;
}
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
Decl *ASTReader::GetDecl(DeclID 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
if (ID == 0)
return 0;
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
if (ID > DeclsLoaded.size()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("declaration ID out-of-range for AST file");
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
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
unsigned Index = ID - 1;
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
if (!DeclsLoaded[Index]) {
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
ReadDeclRecord(Index, 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
if (DeserializationListener)
DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
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
return DeclsLoaded[Index];
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
serialization::DeclID ASTReader::ReadDeclID(Module &F,
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
const RecordData &Record,
unsigned &Idx) {
if (Idx >= Record.size()) {
Error("Corrupted AST file");
return 0;
}
return getGlobalDeclID(F, Record[Idx++]);
}
rename GetStmt -> GetDeclStmt to make it clear that the stmt read is part of a decl. llvm-svn: 70189
2009-04-27 13:46:25 +08:00
/// \brief Resolve the offset of a statement into a statement.
///
/// This operation will read a new statement from the external
/// source each time it is called, and is meant to be used via a
/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
Switch case IDs conflict between chained PCHs; since there is no need to be global, make them local to a decl. llvm-svn: 117540
2010-10-28 17:29:32 +08:00
// Switch case IDs are per Decl.
ClearSwitchCaseIDs();
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
// Offset here is a global offset across the entire chain.
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
RecordLocation Loc = getLocalBitOffset(Offset);
Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
return ReadStmtFromStream(*Loc.F);
Lazy deserialization of function bodies for PCH files. For the Carbon "Hello, World!", this takes us from deserializing 6469 statements/expressions down to deserializing 1 statement/expression. It only translated into a 1% improvement on the Carbon-prefixed 403.gcc, but (a) it's the right thing to do, and (b) we expect this to matter more once we lazily deserialize identifiers. llvm-svn: 69407
2009-04-18 08:07:54 +08:00
}
Augment the interface of ExternalASTSource::FindExternalLexicalDecls() to allow clients to specify that they've already (correctly) loaded declarations, and that no further action is needed. Also, make sure that we clear the "has external lexical declarations" bit before calling FindExternalLexicalDecls(), to avoid infinite recursion. llvm-svn: 135306
2011-07-16 05:46:17 +08:00
ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
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
bool (*isKindWeWant)(Decl::Kind),
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
SmallVectorImpl<Decl*> &Decls) {
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
// There might be lexical decls in multiple parts of the chain, for the TU
// at least.
Fix a use of an invalidated reference due to a hash map reallocating. llvm-svn: 114937
2010-09-28 10:24:44 +08:00
// DeclContextOffsets might reallocate as we load additional decls below,
// so make a copy of the vector.
DeclContextInfos Infos = DeclContextOffsets[DC];
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
for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
I != E; ++I) {
- 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
// IDs can be 0 if this context doesn't contain declarations.
if (!I->LexicalDecls)
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
continue;
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
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
// Load all of the declaration IDs
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
for (const KindDeclIDPair *ID = I->LexicalDecls,
*IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
continue;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Clean up the rest of the local -> global declaration ID mappings within the ASTReader (I hope). llvm-svn: 135720
2011-07-22 07:29:11 +08:00
Decl *D = GetLocalDecl(*I->F, ID->second);
Fix a use of an invalidated reference due to a hash map reallocating. llvm-svn: 114937
2010-09-28 10:24:44 +08:00
assert(D && "Null decl in lexical decls");
Decls.push_back(D);
}
Turn several PCH reader assertions into compiler errors, thus making the PCHReader more robust to corrupt or invalid PCH files. llvm-svn: 98788
2010-03-18 08:56:54 +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
Add PCH statistics for the number/percent of lexical/visible declcontexts read llvm-svn: 69835
2009-04-23 06:34:57 +08:00
++NumLexicalDeclContextsRead;
Augment the interface of ExternalASTSource::FindExternalLexicalDecls() to allow clients to specify that they've already (correctly) loaded declarations, and that no further action is needed. Also, make sure that we clear the "has external lexical declarations" bit before calling FindExternalLexicalDecls(), to avoid infinite recursion. llvm-svn: 135306
2011-07-16 05:46:17 +08:00
return ELR_Success;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Alter the ExternalASTSource interface to permit by-name lookups. PCH continues to bring in the entire lookup table at once. Also, give ExternalSemaSource's vtable a home. This is important because otherwise any reference to it will cause RTTI to be emitted, and since clang is compiled with -fno-rtti, that RTTI will contain unresolved references (to ExternalASTSource's RTTI). So this change makes it possible to subclass ExternalSemaSource from projects compiled with RTTI, as long as the subclass's home is compiled with -fno-rtti. llvm-svn: 105268
2010-06-01 17:23:16 +08:00
DeclContext::lookup_result
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
Alter the ExternalASTSource interface to permit by-name lookups. PCH continues to bring in the entire lookup table at once. Also, give ExternalSemaSource's vtable a home. This is important because otherwise any reference to it will cause RTTI to be emitted, and since clang is compiled with -fno-rtti, that RTTI will contain unresolved references (to ExternalASTSource's RTTI). So this change makes it possible to subclass ExternalSemaSource from projects compiled with RTTI, as long as the subclass's home is compiled with -fno-rtti. llvm-svn: 105268
2010-06-01 17:23:16 +08:00
DeclarationName Name) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(DC->hasExternalVisibleStorage() &&
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 has no visible decls in storage");
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
if (!Name)
return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
DeclContext::lookup_iterator(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
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<NamedDecl *, 64> Decls;
Baby step towards supporting namespaces in chained PCH. llvm-svn: 111878
2010-08-24 08:49:55 +08:00
// There might be visible decls in multiple parts of the chain, for the TU
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
// and namespaces. For any given name, the last available results replace
// all earlier ones. For this reason, we walk in reverse.
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
DeclContextInfos &Infos = DeclContextOffsets[DC];
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 (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
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 != E; ++I) {
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
if (!I->NameLookupTableData)
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
continue;
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
ASTDeclContextNameLookupTable *LookupTable =
(ASTDeclContextNameLookupTable*)I->NameLookupTableData;
ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
if (Pos == LookupTable->end())
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
continue;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
ASTDeclContextNameLookupTrait::data_type Data = *Pos;
for (; Data.first != Data.second; ++Data.first)
Clean up the rest of the local -> global declaration ID mappings within the ASTReader (I hope). llvm-svn: 135720
2011-07-22 07:29:11 +08:00
Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
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
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
}
Add PCH statistics for the number/percent of lexical/visible declcontexts read llvm-svn: 69835
2009-04-23 06:34:57 +08:00
++NumVisibleDeclContextsRead;
Alter the ExternalASTSource interface to permit by-name lookups. PCH continues to bring in the entire lookup table at once. Also, give ExternalSemaSource's vtable a home. This is important because otherwise any reference to it will cause RTTI to be emitted, and since clang is compiled with -fno-rtti, that RTTI will contain unresolved references (to ExternalASTSource's RTTI). So this change makes it possible to subclass ExternalSemaSource from projects compiled with RTTI, as long as the subclass's home is compiled with -fno-rtti. llvm-svn: 105268
2010-06-01 17:23:16 +08:00
Use the AST on-disk hash table for name lookup inside a DeclContext. *Huge* improvement over the amount of deserializing that we do for C++ lookup. e.g, if he have the Carbon header precompiled and include it on a file containing this: int x; these are the before/after stats: BEFORE: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 15907/16501 types read (96.400223%) 53525/59955 declarations read (89.275291%) 33993/43525 identifiers read (78.099945%) 41516/51891 statements read (80.006165%) 77/5317 macros read (1.448185%) 0/6335 lexical declcontexts read (0.000000%) 1/5424 visible declcontexts read (0.018437%) AFTER using the on-disk table: *** AST File Statistics: 578 stat cache hits 4 stat cache misses 548/30654 source location entries read (1.787695%) 10/16501 types read (0.060602%) 9/59955 declarations read (0.015011%) 161/43525 identifiers read (0.369902%) 20/51891 statements read (0.038542%) 6/5317 macros read (0.112846%) 0/6335 lexical declcontexts read (0.000000%) 2/5424 visible declcontexts read (0.036873%) There's only one issue affecting mostly the precompiled preambles which I will address soon. llvm-svn: 111636
2010-08-21 00:04:35 +08:00
SetExternalVisibleDeclsForName(DC, Name, Decls);
Alter the ExternalASTSource interface to permit by-name lookups. PCH continues to bring in the entire lookup table at once. Also, give ExternalSemaSource's vtable a home. This is important because otherwise any reference to it will cause RTTI to be emitted, and since clang is compiled with -fno-rtti, that RTTI will contain unresolved references (to ExternalASTSource's RTTI). So this change makes it possible to subclass ExternalSemaSource from projects compiled with RTTI, as long as the subclass's home is compiled with -fno-rtti. llvm-svn: 105268
2010-06-01 17:23:16 +08:00
return const_cast<DeclContext*>(DC)->lookup(Name);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 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
void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
assert(DC->hasExternalVisibleStorage() &&
"DeclContext has no visible decls in storage");
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<NamedDecl *, 64> Decls;
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
// There might be visible decls in multiple parts of the chain, for the TU
// and namespaces.
DeclContextInfos &Infos = DeclContextOffsets[DC];
for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
I != E; ++I) {
if (!I->NameLookupTableData)
continue;
ASTDeclContextNameLookupTable *LookupTable =
(ASTDeclContextNameLookupTable*)I->NameLookupTableData;
for (ASTDeclContextNameLookupTable::item_iterator
ItemI = LookupTable->item_begin(),
ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
ASTDeclContextNameLookupTable::item_iterator::value_type Val
= *ItemI;
ASTDeclContextNameLookupTrait::data_type Data = Val.second;
Decls.clear();
for (; Data.first != Data.second; ++Data.first)
Clean up the rest of the local -> global declaration ID mappings within the ASTReader (I hope). llvm-svn: 135720
2011-07-22 07:29:11 +08:00
Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
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
MaterializeVisibleDeclsForName(DC, Val.first, Decls);
}
}
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::PassInterestingDeclsToConsumer() {
Delay passing InterestingDecls to the Consumer until when we know we are not in recursive loading and the declarations are fully initialized. llvm-svn: 107783
2010-07-07 23:46:26 +08:00
assert(Consumer);
while (!InterestingDecls.empty()) {
DeclGroupRef DG(InterestingDecls.front());
InterestingDecls.pop_front();
Reintroduce the ASTConsumer/ASTUnit fix from r110610, it has nothing to do with the breakage. llvm-svn: 110840
2010-08-12 02:52:41 +08:00
Consumer->HandleInterestingDecl(DG);
Delay passing InterestingDecls to the Consumer until when we know we are not in recursive loading and the declarations are fully initialized. llvm-svn: 107783
2010-07-07 23:46:26 +08:00
}
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
Minimize the number and kind of "external definitions" that the PCH file needs to store. CodeGen needs to see these definitions (via HandleTopLevelDecl), otherwise it won't be able to generate code for them. This patch notifies the consumer (e.g., CodeGen) about function definitions and variable definitions when the corresponding declarations are deserialized. Hence, we don't eagerly deserialize the declarations for every variable or function that has a definition in the PCH file. This gives another 5% speedup for the Carbon-prefixed "Hello, World!", and brings our PCH statistics down to something far more reasonable: *** PCH Statistics: 13/20693 types read (0.062823%) 17/59230 declarations read (0.028702%) 54/44914 identifiers read (0.120230%) 0/32954 statements read (0.000000%) 5/6187 macros read (0.080815%) llvm-svn: 69820
2009-04-23 03:09:20 +08:00
this->Consumer = Consumer;
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
if (!Consumer)
return;
for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
Delay passing InterestingDecls to the Consumer until when we know we are not in recursive loading and the declarations are fully initialized. llvm-svn: 107783
2010-07-07 23:46:26 +08:00
// Force deserialization of this decl, which will cause it to be queued for
// passing to the consumer.
PCH: When deserializing an explicit "external definition", don't pass it to HandleTopLevelDecl -- this is already being done inside the reader. This is something of a hack, since whether the reader actually did this depends on the "isConsumerInterestedIn" predicate. I think we need to rework how this works, but I need to discuss with Doug. llvm-svn: 82111
2009-09-17 11:06:44 +08:00
GetDecl(ExternalDefinitions[I]);
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
}
Make sure that the consumer sees all interested decls. This fixes Preview llvm-svn: 70007
2009-04-25 08:41:30 +08:00
Delay passing InterestingDecls to the Consumer until when we know we are not in recursive loading and the declarations are fully initialized. llvm-svn: 107783
2010-07-07 23:46:26 +08:00
PassInterestingDeclsToConsumer();
When writing a PCH file, keep track of all of the non-static, non-inline external definitions (and tentative definitions) that are found at the top level. The corresponding declarations are stored in a record in the PCH file, so that they can be provided to the ASTConsumer (via HandleTopLevelDecl) when the PCH file is read. llvm-svn: 69005
2009-04-14 08:24:19 +08:00
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::PrintStats() {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
std::fprintf(stderr, "*** AST File Statistics:\n");
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
unsigned NumTypesLoaded
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
= TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
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
QualType());
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
unsigned NumDeclsLoaded
= DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
(Decl *)0);
unsigned NumIdentifiersLoaded
= IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
IdentifiersLoaded.end(),
(IdentifierInfo *)0);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
unsigned NumSelectorsLoaded
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
= SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
SelectorsLoaded.end(),
Selector());
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
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
std::fprintf(stderr, " %u stat cache hits\n", NumStatHits);
std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses);
In the AST reader, keep track of the total number of source locations entries incrementally, rather than iterating over the chain when loading a single AST file. llvm-svn: 135692
2011-07-22 02:46:38 +08:00
if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
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
std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
NumSLocEntriesRead, TotalNumSLocEntries,
((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
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
if (!TypesLoaded.empty())
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
std::fprintf(stderr, " %u/%u types read (%f%%)\n",
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
NumTypesLoaded, (unsigned)TypesLoaded.size(),
((float)NumTypesLoaded/TypesLoaded.size() * 100));
if (!DeclsLoaded.empty())
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
std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
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
NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
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
if (!IdentifiersLoaded.empty())
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
std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
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
NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
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
if (!SelectorsLoaded.empty())
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
std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
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
NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
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
if (TotalNumStatements)
std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
NumStatementsRead, TotalNumStatements,
((float)NumStatementsRead/TotalNumStatements * 100));
if (TotalNumMacros)
std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
NumMacrosRead, TotalNumMacros,
((float)NumMacrosRead/TotalNumMacros * 100));
if (TotalLexicalDeclContexts)
std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
* 100));
if (TotalVisibleDeclContexts)
std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
* 100));
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
if (TotalNumMethodPoolEntries) {
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
std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
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
* 100));
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses);
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
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
std::fprintf(stderr, "\n");
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
dump();
std::fprintf(stderr, "\n");
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
template<typename Key, typename Module, unsigned InitialCapacity>
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
static void
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
dumpModuleIDMap(StringRef Name,
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
const ContinuousRangeMap<Key, Module *,
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
InitialCapacity> &Map) {
if (Map.begin() == Map.end())
return;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
llvm::errs() << Name << ":\n";
for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
I != IEnd; ++I) {
llvm::errs() << " " << I->first << " -> " << I->second->FileName
<< "\n";
}
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
template<typename Key, typename Module, typename Adjustment,
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
unsigned InitialCapacity>
static void
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
dumpModuleIDOffsetMap(StringRef Name,
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
const ContinuousRangeMap<Key,
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
std::pair<Module *,
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
Adjustment>,
InitialCapacity> &Map) {
if (Map.begin() == Map.end())
return;
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
typedef ContinuousRangeMap<Key, std::pair<Module *, Adjustment>,
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
InitialCapacity> MapType;
llvm::errs() << Name << ":\n";
for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
I != IEnd; ++I) {
llvm::errs() << " " << I->first << " -> (" << I->second.first->FileName
<< ", " << I->second.second << ")\n";
}
}
void ASTReader::dump() {
llvm::errs() << "*** AST File Remapping:\n";
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
dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
Add some debugging output to the AST reader, so we can see the global remappings we generate llvm-svn: 135701
2011-07-22 03:50:14 +08:00
dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
dumpModuleIDOffsetMap("Global type map", GlobalTypeMap);
dumpModuleIDOffsetMap("Global declaration map", GlobalDeclMap);
dumpModuleIDOffsetMap("Global identifier map", GlobalIdentifierMap);
dumpModuleIDOffsetMap("Global selector map", GlobalSelectorMap);
dumpModuleIDOffsetMap("Global macro definition map",
GlobalMacroDefinitionMap);
dumpModuleIDOffsetMap("Global preprocessed entity map",
GlobalPreprocessedEntityMap);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
}
Enhance clang_getCXTUResourceUsage() to report the sizes of the memory buffers used by PCH. llvm-svn: 130460
2011-04-29 07:46:20 +08:00
/// Return the amount of memory used by memory buffers, breaking down
/// by heap-backed versus mmap'ed memory.
void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleConstIterator I = ModuleMgr.begin(),
E = ModuleMgr.end(); I != E; ++I) {
if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
Enhance clang_getCXTUResourceUsage() to report the sizes of the memory buffers used by PCH. llvm-svn: 130460
2011-04-29 07:46:20 +08:00
size_t bytes = buf->getBufferSize();
switch (buf->getBufferKind()) {
case llvm::MemoryBuffer::MemoryBuffer_Malloc:
sizes.malloc_bytes += bytes;
break;
case llvm::MemoryBuffer::MemoryBuffer_MMap:
sizes.mmap_bytes += bytes;
break;
}
}
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
}
Enhance clang_getCXTUResourceUsage() to report the sizes of the memory buffers used by PCH. llvm-svn: 130460
2011-04-29 07:46:20 +08:00
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::InitializeSema(Sema &S) {
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
SemaObj = &S;
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
S.ExternalSource = this;
Eliminate some FIXMEs in the PCH reader that were either already fixed or aren't actually things to fix llvm-svn: 69827
2009-04-23 05:15:06 +08:00
// Makes sure any declarations that were deserialized "too early"
// still get added to the identifier's declaration chains.
When setting the globally-visible declarations for a particular identifier, we may have a Sema object but no translation unit scope (because parsing is finished). In this case, we still need to update the IdResolver, which might still be used when writing a PCH containing another PCH (without chaining). This bug manifested as a failure with precompiled preambles. Also, add a little environment-variable-sensitive logging for libclang. llvm-svn: 114774
2010-09-25 07:29:12 +08:00
for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
if (SemaObj->TUScope)
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
When setting the globally-visible declarations for a particular identifier, we may have a Sema object but no translation unit scope (because parsing is finished). In this case, we still need to update the IdResolver, which might still be used when writing a PCH containing another PCH (without chaining). This bug manifested as a failure with precompiled preambles. Also, add a little environment-variable-sensitive logging for libclang. llvm-svn: 114774
2010-09-25 07:29:12 +08:00
SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
Eliminate some FIXMEs in the PCH reader that were either already fixed or aren't actually things to fix llvm-svn: 69827
2009-04-23 05:15:06 +08:00
}
PreloadedDecls.clear();
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
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
// Load the offsets of the declarations that Sema references.
// They will be lazily deserialized when needed.
if (!SemaDeclRefs.empty()) {
assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
Don't set Sema's StdNamespace or StdBadAlloc if they've already been set llvm-svn: 136318
2011-07-28 08:57:24 +08:00
if (!SemaObj->StdNamespace)
SemaObj->StdNamespace = SemaDeclRefs[0];
if (!SemaObj->StdBadAlloc)
SemaObj->StdBadAlloc = SemaDeclRefs[1];
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
}
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
if (!FPPragmaOptions.empty()) {
assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
}
if (!OpenCLExtensions.empty()) {
unsigned I = 0;
#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
#include "clang/Basic/OpenCLExtensions.def"
assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
}
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
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
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
// Try to find this name within our on-disk hash tables. We start with the
// most recent one, since that one contains the most up-to-date info.
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTIdentifierLookupTable *IdTable
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
= (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
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
if (!IdTable)
continue;
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
if (Pos == IdTable->end())
continue;
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
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
// Dereferencing the iterator has the effect of building the
// IdentifierInfo node and populating it with the various
// declarations it needs.
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
return *Pos;
Allow loading macros from any file in the chain. WIP llvm-svn: 109048
2010-07-22 06:31:37 +08:00
}
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
return 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
}
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
namespace clang {
/// \brief An identifier-lookup iterator that enumerates all of the
/// identifiers stored within a set of AST files.
class ASTIdentifierIterator : public IdentifierIterator {
/// \brief The AST reader whose identifiers are being enumerated.
const ASTReader &Reader;
/// \brief The current index into the chain of AST files stored in
/// the AST reader.
unsigned Index;
/// \brief The current position within the identifier lookup table
/// of the current AST file.
ASTIdentifierLookupTable::key_iterator Current;
/// \brief The end position within the identifier lookup table of
/// the current AST file.
ASTIdentifierLookupTable::key_iterator End;
public:
explicit ASTIdentifierIterator(const ASTReader &Reader);
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
virtual StringRef Next();
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
};
}
ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
: Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
ASTIdentifierLookupTable *IdTable
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
= (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
Current = IdTable->key_begin();
End = IdTable->key_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
StringRef ASTIdentifierIterator::Next() {
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
while (Current == End) {
// If we have exhausted all of our AST files, we're done.
if (Index == 0)
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
return StringRef();
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
--Index;
ASTIdentifierLookupTable *IdTable
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
= (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
IdentifierLookupTable;
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
Current = IdTable->key_begin();
End = IdTable->key_end();
}
// We have any identifiers remaining in the current AST file; return
// the next one.
std::pair<const char*, unsigned> Key = *Current;
++Current;
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
return StringRef(Key.first, Key.second);
When performing typo correction, look through the set of known identifiers to determine good typo-correction candidates. Once we've identified those candidates, we perform name lookup on each of them and the consider the results. This optimization makes typo correction > 2x faster on a benchmark example using a single typo (NSstring) in a tiny file that includes Cocoa.h from a precompiled header, since we are deserializing far less information now during typo correction. There is a semantic change here, which is interesting. The presence of a similarly-named entity that is not visible can now affect typo correction. This is both good (you won't get weird corrections if the thing you wanted isn't in scope) and bad (you won't get good corrections if there is a similarly-named-but-completely-unrelated thing). Time will tell whether it was a good choice or not. llvm-svn: 116528
2010-10-15 06:11:03 +08:00
}
IdentifierIterator *ASTReader::getIdentifiers() const {
return new ASTIdentifierIterator(*this);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<ObjCMethodList, ObjCMethodList>
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::ReadMethodPool(Selector Sel) {
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
// Find this selector in a hash table. We want to find the most recent entry.
Refactor of how modules are handled in ASTReader to remove explicit uses of a chain of AST files, instead redirect calls through a module manager. This should help move toward a DAG and the potential of loading multiple, unrelated PCH files. It's still early in development. llvm-svn: 135957
2011-07-26 04:32:21 +08:00
for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
Module &F = *(*I);
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
if (!F.SelectorLookupTable)
continue;
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
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTSelectorLookupTable *PoolTable
= (ASTSelectorLookupTable*)F.SelectorLookupTable;
ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
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
if (Pos != PoolTable->end()) {
++NumSelectorsRead;
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
// FIXME: Not quite happy with the statistics here. We probably should
// disable this tracking when called via LoadSelector.
// Also, should entries without methods count as misses?
++NumMethodPoolEntriesRead;
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTSelectorLookupTrait::data_type Data = *Pos;
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
if (DeserializationListener)
DeserializationListener->SelectorRead(Data.ID, Sel);
return std::make_pair(Data.Instance, Data.Factory);
}
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
}
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
Bring stats for the method pool back. llvm-svn: 110247
2010-08-05 05:22:45 +08:00
++NumMethodPoolMisses;
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
return std::pair<ObjCMethodList, ObjCMethodList>();
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
}
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
void ASTReader::ReadKnownNamespaces(
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
SmallVectorImpl<NamespaceDecl *> &Namespaces) {
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
Namespaces.clear();
for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
if (NamespaceDecl *Namespace
= dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
Namespaces.push_back(Namespace);
}
}
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
void ASTReader::ReadTentativeDefinitions(
SmallVectorImpl<VarDecl *> &TentativeDefs) {
for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
if (Var)
TentativeDefs.push_back(Var);
}
TentativeDefinitions.clear();
}
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
void ASTReader::ReadUnusedFileScopedDecls(
SmallVectorImpl<const DeclaratorDecl *> &Decls) {
for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
DeclaratorDecl *D
= dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
if (D)
Decls.push_back(D);
}
UnusedFileScopedDecls.clear();
}
Turn Sema::DelegatingCtorDecls into a LazyVector. llvm-svn: 136273
2011-07-28 05:57:17 +08:00
void ASTReader::ReadDelegatingConstructors(
SmallVectorImpl<CXXConstructorDecl *> &Decls) {
for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
CXXConstructorDecl *D
= dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
if (D)
Decls.push_back(D);
}
DelegatingCtorDecls.clear();
}
Switch Sema::ExtVectorDecls over to LazyVector. llvm-svn: 136314
2011-07-28 08:39:29 +08:00
void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
TypedefNameDecl *D
= dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
if (D)
Decls.push_back(D);
}
ExtVectorDecls.clear();
}
Switch Sema::DynamicClasses over to LazyVector llvm-svn: 136317
2011-07-28 08:53:40 +08:00
void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
CXXRecordDecl *D
= dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
if (D)
Decls.push_back(D);
}
DynamicClasses.clear();
}
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
void
ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
NamedDecl *D
= dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
if (D)
Decls.push_back(D);
}
LocallyScopedExternalDecls.clear();
}
Make Sema::ReferencedSelectors lazily deserialized. llvm-svn: 136357
2011-07-28 22:54:22 +08:00
void ASTReader::ReadReferencedSelectors(
SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
if (ReferencedSelectorsData.empty())
return;
// If there are @selector references added them to its pool. This is for
// implementation of -Wselector.
unsigned int DataSize = ReferencedSelectorsData.size()-1;
unsigned I = 0;
while (I < DataSize) {
Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
SourceLocation SelLoc
= SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
Sels.push_back(std::make_pair(Sel, SelLoc));
}
ReferencedSelectorsData.clear();
}
Make Sema::WeakUndeclaredIdentifiers lazily deserialized. llvm-svn: 136368
2011-07-29 02:09:57 +08:00
void ASTReader::ReadWeakUndeclaredIdentifiers(
SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
if (WeakUndeclaredIdentifiers.empty())
return;
for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
IdentifierInfo *WeakId
= DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
IdentifierInfo *AliasId
= DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
SourceLocation Loc
= SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
bool Used = WeakUndeclaredIdentifiers[I++];
WeakInfo WI(AliasId, Loc);
WI.setUsed(Used);
WeakIDs.push_back(std::make_pair(WeakId, WI));
}
WeakUndeclaredIdentifiers.clear();
}
Lazily deserialize Sema::VTableUses. Plus, fix the utterly and completely broken deserialization mapping code we had for VTableUses, which would have broken horribly as soon as our local-to-global ID mapping became interesting. llvm-svn: 136371
2011-07-29 03:11:31 +08:00
void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
ExternalVTableUse VT;
VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
VT.DefinitionRequired = VTableUses[Idx++];
VTables.push_back(VT);
}
VTableUses.clear();
}
Make the deserialization of Sema::PendingInstantiations lazy. At this point, ASTReader::InitializeSema() has very little interesting work, *except* issues stemming from preloaded declarations. That's something we'll still need to cope with. llvm-svn: 136378
2011-07-29 03:49:54 +08:00
void ASTReader::ReadPendingInstantiations(
SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
SourceLocation Loc
= SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
Pending.push_back(std::make_pair(D, Loc));
}
PendingInstantiations.clear();
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::LoadSelector(Selector Sel) {
When chaining, only write interesting selectors to the PCH. llvm-svn: 110229
2010-08-05 02:21:41 +08:00
// It would be complicated to avoid reading the methods anyway. So don't.
ReadMethodPool(Sel);
}
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *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
assert(ID && "Non-zero identifier ID required");
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
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
IdentifiersLoaded[ID - 1] = II;
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
if (DeserializationListener)
DeserializationListener->IdentifierRead(ID, 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
}
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
/// \brief Set the globally-visible declarations associated with the given
/// identifier.
///
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
/// If the AST reader is currently in a state where the given declaration IDs
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
/// cannot safely be resolved, they are queued until it is safe to resolve
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
/// them.
///
/// \param II an IdentifierInfo that refers to one or more globally-visible
/// declarations.
///
/// \param DeclIDs the set of declaration IDs with the name @p II that are
/// visible at global scope.
///
/// \param Nonrecursive should be true to indicate that the caller knows that
/// this call is non-recursive, and therefore the globally-visible declarations
/// will not be placed onto the pending queue.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
void
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
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
const SmallVectorImpl<uint32_t> &DeclIDs,
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
bool Nonrecursive) {
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
if (NumCurrentElementsDeserializing && !Nonrecursive) {
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
PendingIdentifierInfos.push_back(PendingIdentifierInfo());
PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
PII.II = II;
Replace loops with SmallVector::append. llvm-svn: 113185
2010-09-07 07:43:28 +08:00
PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
if (SemaObj) {
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
if (SemaObj->TUScope) {
// Introduce this declaration into the translation-unit scope
// and add it to the declaration chain for this identifier, so
// that (unqualified) name lookup will find it.
DeclPtrTy -> Decl * llvm-svn: 111733
2010-08-21 17:40:31 +08:00
SemaObj->TUScope->AddDecl(D);
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
}
When setting the globally-visible declarations for a particular identifier, we may have a Sema object but no translation unit scope (because parsing is finished). In this case, we still need to update the IdResolver, which might still be used when writing a PCH containing another PCH (without chaining). This bug manifested as a failure with precompiled preambles. Also, add a little environment-variable-sensitive logging for libclang. llvm-svn: 114774
2010-09-25 07:29:12 +08:00
SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
} else {
// Queue this declaration so that it will be added to the
// translation unit scope and identifier's declaration chain
// once a Sema object is known.
PreloadedDecls.push_back(D);
}
}
}
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
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)
return 0;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Allow loading identifiers from any file in the chain. WIP llvm-svn: 108974
2010-07-21 08:46:22 +08:00
if (IdentifiersLoaded.empty()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("no identifier table in 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
return 0;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
assert(PP && "Forgot to set Preprocessor ?");
Allow loading identifiers from any file in the chain. WIP llvm-svn: 108974
2010-07-21 08:46:22 +08:00
ID -= 1;
if (!IdentifiersLoaded[ID]) {
Use a ContinuousRangeMap to map from the global identifier ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135551
2011-07-20 08:59:32 +08:00
GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
unsigned Index = ID + I->second.second;
const char *Str = I->second.first->IdentifierTableData
+ I->second.first->IdentifierOffsets[Index];
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
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// All of the strings in the AST file are preceded by a 16-bit length.
// Extract that 16-bit length to avoid having to execute strlen().
Add comment. llvm-svn: 84930
2009-10-23 12:45:31 +08:00
// NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
// unsigned integers. This is important to avoid integer overflow when
// we cast them to 'unsigned'.
Fix integer overflow in PCHReader when reading the length of an identifier. This caused a crash when reading PCH files that contained long identifier names. The issue is that 'StrLenPtr' was previously a 'const char *', meaning the byte loaded from it would be interpretted as a signed integer. If the topmost bit was set, conversion to 'unsigned' would extend that bit, causing an overflow. The solution is to make 'StrLenPtr' an 'unsigned char *', always treating the value as an unsigned integer. This fixes: <rdar://problem/7328900> llvm-svn: 84925
2009-10-23 11:57:22 +08:00
const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
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
unsigned StrLen = (((unsigned) StrLenPtr[0])
| (((unsigned) StrLenPtr[1]) << 8)) - 1;
Allow loading identifiers from any file in the chain. WIP llvm-svn: 108974
2010-07-21 08:46:22 +08:00
IdentifiersLoaded[ID]
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
= &PP->getIdentifierTable().get(StringRef(Str, StrLen));
Make declarations in the dependent PCH visible, for C at least. llvm-svn: 109292
2010-07-24 07:49:55 +08:00
if (DeserializationListener)
DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
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
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Allow loading identifiers from any file in the chain. WIP llvm-svn: 108974
2010-07-21 08:46:22 +08:00
return IdentifiersLoaded[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
}
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
}
IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
// FIXME: Perform local-to-global remapping
return LocalID;
}
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
bool ASTReader::ReadSLocEntry(int ID) {
Teach SourceManager::getSLocEntry() that it can fail due to problems during deserialization from a precompiled header, and update all of its callers to note when this problem occurs and recover (more) gracefully. Fixes <rdar://problem/9119249>. llvm-svn: 129839
2011-04-20 08:21:03 +08:00
return ReadSLocEntryRecord(ID) != Success;
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
}
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
return DecodeSelector(getGlobalSelectorID(M, LocalID));
}
Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
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 (ID == 0)
return Selector();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
if (ID > SelectorsLoaded.size()) {
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
Error("selector ID out of range in AST file");
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
return Selector();
}
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
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
if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
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
// Load this selector from the selector table.
Use a ContinuousRangeMap to map from the global selector ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135554
2011-07-20 09:10:58 +08:00
GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F = *I->second.first;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ASTSelectorLookupTrait Trait(*this, F);
Use a ContinuousRangeMap to map from the global selector ID in the AST reader down to the AST file + local ID, rather than walking the PCH chain. No functionality change; this is generalization and cleanup. llvm-svn: 135554
2011-07-20 09:10:58 +08:00
unsigned Idx = ID - 1 + I->second.second;
SelectorsLoaded[ID - 1] =
Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0);
if (DeserializationListener)
DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
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
}
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
return SelectorsLoaded[ID - 1];
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
}
Move a Module's ReferencedSelectorsData into the ASTReader itself, so that it accumulates referenced selectors from each of the modules/PCH files as they are loaded. No actual functionality change, yet. llvm-svn: 136356
2011-07-28 22:41:43 +08:00
Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
Make code-completion for Objective-C message sends to "id" work in the presence of precompiled headers by forcibly loading all of the methods we know about from the PCH file before constructing our code-completion list. llvm-svn: 100535
2010-04-07 01:30:22 +08:00
return DecodeSelector(ID);
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
uint32_t ASTReader::GetNumExternalSelectors() {
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
// ID 0 (the null selector) is considered an external selector.
return getTotalNumSelectors() + 1;
Make code-completion for Objective-C message sends to "id" work in the presence of precompiled headers by forcibly loading all of the methods we know about from the PCH file before constructing our code-completion list. llvm-svn: 100535
2010-04-07 01:30:22 +08:00
}
Move a Module's ReferencedSelectorsData into the ASTReader itself, so that it accumulates referenced selectors from each of the modules/PCH files as they are loaded. No actual functionality change, yet. llvm-svn: 136356
2011-07-28 22:41:43 +08:00
serialization::SelectorID
ASTReader::getGlobalSelectorID(Module &F, unsigned LocalID) const {
// FIXME: Perform local -> global remapping
return LocalID;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
DeclarationName
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadDeclarationName(Module &F,
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
const RecordData &Record, unsigned &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
DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
switch (Kind) {
case DeclarationName::Identifier:
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
return DeclarationName(GetIdentifierInfo(F, Record, 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
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Use the local -> global mapping functions for selectors more consistently in the ASTReader. llvm-svn: 136395
2011-07-29 05:16:51 +08:00
return DeclarationName(ReadSelector(F, Record, 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
case DeclarationName::CXXConstructorName:
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->DeclarationNames.getCXXConstructorName(
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Context->getCanonicalType(readType(F, Record, 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
case DeclarationName::CXXDestructorName:
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->DeclarationNames.getCXXDestructorName(
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Context->getCanonicalType(readType(F, Record, 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
case DeclarationName::CXXConversionFunctionName:
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->DeclarationNames.getCXXConversionFunctionName(
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Context->getCanonicalType(readType(F, Record, 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
case DeclarationName::CXXOperatorName:
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
return Context->DeclarationNames.getCXXOperatorName(
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
(OverloadedOperatorKind)Record[Idx++]);
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:
return Context->DeclarationNames.getCXXLiteralOperatorName(
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
GetIdentifierInfo(F, Record, Idx));
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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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:
return DeclarationName::getUsingDirectiveName();
}
// Required to silence GCC warning
return DeclarationName();
}
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
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
void ASTReader::ReadDeclarationNameLoc(Module &F,
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
DeclarationNameLoc &DNLoc,
DeclarationName Name,
const RecordData &Record, unsigned &Idx) {
switch (Name.getNameKind()) {
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
break;
case DeclarationName::CXXOperatorName:
DNLoc.CXXOperatorName.BeginOpNameLoc
= ReadSourceLocation(F, Record, Idx).getRawEncoding();
DNLoc.CXXOperatorName.EndOpNameLoc
= ReadSourceLocation(F, Record, Idx).getRawEncoding();
break;
case DeclarationName::CXXLiteralOperatorName:
DNLoc.CXXLiteralOperatorName.OpNameLoc
= ReadSourceLocation(F, Record, Idx).getRawEncoding();
break;
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXUsingDirective:
break;
}
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
void ASTReader::ReadDeclarationNameInfo(Module &F,
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
DeclarationNameInfo &NameInfo,
const RecordData &Record, unsigned &Idx) {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
NameInfo.setName(ReadDeclarationName(F, Record, Idx));
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
DeclarationNameLoc DNLoc;
ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
NameInfo.setInfo(DNLoc);
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
const RecordData &Record, unsigned &Idx) {
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
Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
unsigned NumTPLists = Record[Idx++];
Info.NumTemplParamLists = NumTPLists;
if (NumTPLists) {
Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
for (unsigned i=0; i != NumTPLists; ++i)
Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
}
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
TemplateName
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
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
unsigned &Idx) {
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
switch (Kind) {
case TemplateName::Template:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateName::OverloadedTemplate: {
unsigned size = Record[Idx++];
UnresolvedSet<8> Decls;
while (size--)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateName::QualifiedTemplate: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
bool hasTemplKeyword = Record[Idx++];
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateName::DependentTemplate: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
if (Record[Idx++]) // isIdentifier
return Context->getDependentTemplateName(NNS,
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
GetIdentifierInfo(F, Record,
Idx));
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
return Context->getDependentTemplateName(NNS,
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
(OverloadedOperatorKind)Record[Idx++]);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
}
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: {
TemplateTemplateParmDecl *param
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
= ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
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
if (!param) return TemplateName();
TemplateName replacement = ReadTemplateName(F, Record, Idx);
return Context->getSubstTemplateTemplateParm(param, replacement);
}
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: {
TemplateTemplateParmDecl *Param
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
= ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
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
if (!Param)
return TemplateName();
TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
if (ArgPack.getKind() != TemplateArgument::Pack)
return TemplateName();
return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
assert(0 && "Unhandled template name kind!");
return TemplateName();
}
TemplateArgument
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadTemplateArgument(Module &F,
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
const RecordData &Record, unsigned &Idx) {
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
TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
switch (Kind) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateArgument::Null:
return TemplateArgument();
case TemplateArgument::Type:
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
return TemplateArgument(readType(F, Record, Idx));
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateArgument::Declaration:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
return TemplateArgument(ReadDecl(F, Record, Idx));
Fix various bugs in recent commits for C++ PCH. llvm-svn: 106995
2010-06-28 17:31:34 +08:00
case TemplateArgument::Integral: {
llvm::APSInt Value = ReadAPSInt(Record, Idx);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
QualType T = readType(F, Record, Idx);
Fix various bugs in recent commits for C++ PCH. llvm-svn: 106995
2010-06-28 17:31:34 +08:00
return TemplateArgument(Value, T);
}
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::Template:
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
return TemplateArgument(ReadTemplateName(F, Record, Idx));
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: {
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
TemplateName Name = ReadTemplateName(F, Record, Idx);
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
llvm::Optional<unsigned> NumTemplateExpansions;
if (unsigned NumExpansions = Record[Idx++])
NumTemplateExpansions = NumExpansions - 1;
return TemplateArgument(Name, NumTemplateExpansions);
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
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateArgument::Expression:
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return TemplateArgument(ReadExpr(F));
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateArgument::Pack: {
unsigned NumArgs = Record[Idx++];
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
TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
for (unsigned I = 0; I != NumArgs; ++I)
Args[I] = ReadTemplateArgument(F, Record, Idx);
return TemplateArgument(Args, NumArgs);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
}
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
assert(0 && "Unhandled template argument kind!");
return TemplateArgument();
}
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
TemplateParameterList *
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadTemplateParameterList(Module &F,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
const RecordData &Record, unsigned &Idx) {
SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
unsigned NumParams = Record[Idx++];
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<NamedDecl *, 16> Params;
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
Params.reserve(NumParams);
while (NumParams--)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
TemplateParameterList* TemplateParams =
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
Params.data(), Params.size(), RAngleLoc);
return TemplateParams;
}
void
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::
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
ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module &F, const RecordData &Record,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
unsigned &Idx) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
unsigned NumTemplateArgs = Record[Idx++];
TemplArgs.reserve(NumTemplateArgs);
while (NumTemplateArgs--)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
}
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
/// \brief Read a UnresolvedSet structure.
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
const RecordData &Record, unsigned &Idx) {
unsigned NumDecls = Record[Idx++];
while (NumDecls--) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
Set.addDecl(D, AS);
}
}
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
CXXBaseSpecifier
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadCXXBaseSpecifier(Module &F,
Add source location information to C++ base specifiers. llvm-svn: 109396
2010-07-27 00:56:01 +08:00
const RecordData &Record, unsigned &Idx) {
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
bool isVirtual = static_cast<bool>(Record[Idx++]);
bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
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
bool inheritConstructors = static_cast<bool>(Record[Idx++]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
SourceRange Range = ReadSourceRange(F, Record, Idx);
Implement pack expansions whose pattern is a base-specifier. llvm-svn: 122782
2011-01-04 06:36:02 +08:00
SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
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
CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
Implement pack expansions whose pattern is a base-specifier. llvm-svn: 122782
2011-01-04 06:36:02 +08:00
EllipsisLoc);
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
Result.setInheritConstructors(inheritConstructors);
return Result;
Read/write CastExpr's CXXBaseSpecifierArray for PCH. llvm-svn: 107542
2010-07-03 07:30:27 +08:00
}
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
std::pair<CXXCtorInitializer **, unsigned>
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
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
unsigned &Idx) {
CXXCtorInitializer **CtorInitializers = 0;
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
unsigned NumInitializers = Record[Idx++];
if (NumInitializers) {
ASTContext &C = *getContext();
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
CtorInitializers
= new (C) CXXCtorInitializer*[NumInitializers];
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
for (unsigned i=0; i != NumInitializers; ++i) {
TypeSourceInfo *BaseClassInfo = 0;
bool IsBaseVirtual = false;
FieldDecl *Member = 0;
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
IndirectFieldDecl *IndirectMember = 0;
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
CXXConstructorDecl *Target = 0;
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
switch (Type) {
case CTOR_INITIALIZER_BASE:
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
IsBaseVirtual = Record[Idx++];
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
break;
case CTOR_INITIALIZER_DELEGATING:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
break;
case CTOR_INITIALIZER_MEMBER:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
break;
case CTOR_INITIALIZER_INDIRECT_MEMBER:
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
break;
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
}
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
Implement pack expansion of base initializers, so that we can initialize those lovely mixins that come from pack expansions of base specifiers. llvm-svn: 122793
2011-01-04 08:32:56 +08:00
SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Expr *Init = ReadExpr(F);
SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
bool IsWritten = Record[Idx++];
unsigned SourceOrderOrNumArrayIndices;
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<VarDecl *, 8> Indices;
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
if (IsWritten) {
SourceOrderOrNumArrayIndices = Record[Idx++];
} else {
SourceOrderOrNumArrayIndices = Record[Idx++];
Indices.reserve(SourceOrderOrNumArrayIndices);
for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
}
Fix Whitespace. llvm-svn: 116990
2010-10-21 11:16:25 +08:00
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
CXXCtorInitializer *BOMInit;
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
if (Type == CTOR_INITIALIZER_BASE) {
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
BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
LParenLoc, Init, RParenLoc,
MemberOrEllipsisLoc);
Implement serialization of delegating constructors. llvm-svn: 130822
2011-05-04 09:19:08 +08:00
} else if (Type == CTOR_INITIALIZER_DELEGATING) {
BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
Target, Init, RParenLoc);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
} else if (IsWritten) {
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
if (Member)
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
BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
LParenLoc, Init, RParenLoc);
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
else
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
BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
MemberOrEllipsisLoc, LParenLoc,
Init, RParenLoc);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
} else {
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
BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
LParenLoc, Init, RParenLoc,
Indices.data(), Indices.size());
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
}
Fix a C++ PCH problem which was exposed by r113019. CXXBaseOrMemberInitializer's IsWritten and source order is not set. llvm-svn: 113161
2010-09-07 03:04:27 +08:00
if (IsWritten)
BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
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
CtorInitializers[i] = BOMInit;
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
}
}
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
return std::make_pair(CtorInitializers, NumInitializers);
Refactor into functions PCH reading/writing the CXXBaseOrMemberInitializers. No functionality change. llvm-svn: 110566
2010-08-09 18:54:12 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
NestedNameSpecifier *
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadNestedNameSpecifier(Module &F,
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
const RecordData &Record, unsigned &Idx) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
unsigned N = Record[Idx++];
NestedNameSpecifier *NNS = 0, *Prev = 0;
for (unsigned I = 0; I != N; ++I) {
NestedNameSpecifier::SpecifierKind Kind
= (NestedNameSpecifier::SpecifierKind)Record[Idx++];
switch (Kind) {
case NestedNameSpecifier::Identifier: {
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
NNS = NestedNameSpecifier::Create(*Context, Prev, II);
break;
}
case NestedNameSpecifier::Namespace: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
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: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
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
NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
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: {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
Eliminate the branching in QualType::getTypePtr() by providing a common base for ExtQuals and Type that stores the underlying type pointer. This results in a 2% performance win for -emit-llvm on a typical C file, with 1% memory growth in the AST. Note that there is an API change in this optimization: QualType::getTypePtr() can no longer be invoked on a NULL QualType. If the QualType might be NULL, use QualType::getTypePtrOrNull(). I've audited all uses of getTypePtr() in the code base and changed the appropriate uses over to getTypePtrOrNull(). A future optimization opportunity would be to distinguish between cast/dyn_cast and cast_or_null/dyn_cast_or_null; for the former, we could use getTypePtr() rather than getTypePtrOrNull(), to take another branch out of the cast/dyn_cast implementation. llvm-svn: 121489
2010-12-11 01:03:06 +08:00
if (!T)
return 0;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
bool Template = Record[Idx++];
NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
break;
}
case NestedNameSpecifier::Global: {
NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
// No associated value, and there can't be a prefix.
break;
}
}
Fix broken reading of NestedNameSpecifiers from PCH. llvm-svn: 107784
2010-07-07 23:46:30 +08:00
Prev = NNS;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
return NNS;
}
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
NestedNameSpecifierLoc
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &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
unsigned &Idx) {
unsigned N = Record[Idx++];
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
NestedNameSpecifierLocBuilder Builder;
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 (unsigned I = 0; I != N; ++I) {
NestedNameSpecifier::SpecifierKind Kind
= (NestedNameSpecifier::SpecifierKind)Record[Idx++];
switch (Kind) {
case NestedNameSpecifier::Identifier: {
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
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
SourceRange Range = ReadSourceRange(F, Record, Idx);
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
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
break;
}
case NestedNameSpecifier::Namespace: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
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
SourceRange Range = ReadSourceRange(F, Record, Idx);
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
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
break;
}
case NestedNameSpecifier::NamespaceAlias: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
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
SourceRange Range = ReadSourceRange(F, Record, Idx);
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
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
break;
}
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
bool Template = Record[Idx++];
TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
if (!T)
return NestedNameSpecifierLoc();
SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
// FIXME: 'template' keyword location not saved anywhere, so we fake it.
Builder.Extend(*Context,
Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
T->getTypeLoc(), ColonColonLoc);
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
break;
}
case NestedNameSpecifier::Global: {
SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
Builder.MakeGlobal(*Context, ColonColonLoc);
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
break;
}
}
}
Refactor the construction of nested-name-specifiers with source-location information into a NestedNameSpecifierLocBuilder class, which lives within the AST library and centralize all knowledge of the format of nested-name-specifier location information here. No functionality change. llvm-svn: 126716
2011-03-01 07:58:31 +08:00
return Builder.getWithLocInContext(*Context);
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
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
SourceRange
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
unsigned &Idx) {
SourceLocation beg = ReadSourceLocation(F, Record, Idx);
SourceLocation end = ReadSourceLocation(F, Record, Idx);
Fix undefined behavior, noticed by GCC 4.5. Patch by Dimitry Andric! llvm-svn: 105329
2010-06-02 23:47:10 +08:00
return SourceRange(beg, end);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Add PCH support for enumerations and enumerators. llvm-svn: 68974
2009-04-14 02:14:40 +08:00
/// \brief Read an integral value
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
Add PCH support for enumerations and enumerators. llvm-svn: 68974
2009-04-14 02:14:40 +08:00
unsigned BitWidth = Record[Idx++];
unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
Idx += NumWords;
return Result;
}
/// \brief Read a signed integral value
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
Add PCH support for enumerations and enumerators. llvm-svn: 68974
2009-04-14 02:14:40 +08:00
bool isUnsigned = Record[Idx++];
return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
}
Add PCH support for PredefinedExpr and FloatingLiteral expressions llvm-svn: 69084
2009-04-15 05:55:33 +08:00
/// \brief Read a floating-point value
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
Add PCH support for PredefinedExpr and FloatingLiteral expressions llvm-svn: 69084
2009-04-15 05:55:33 +08:00
return llvm::APFloat(ReadAPInt(Record, Idx));
}
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
// \brief Read a string
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
unsigned Len = Record[Idx++];
Use v.data() instead of &v[0] when SmallVector v might be empty. llvm-svn: 72210
2009-05-21 17:52:38 +08:00
std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
PCH support for declaration attributes llvm-svn: 69225
2009-04-16 05:30:51 +08:00
Idx += Len;
return Result;
}
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
VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
unsigned &Idx) {
unsigned Major = Record[Idx++];
unsigned Minor = Record[Idx++];
unsigned Subminor = Record[Idx++];
if (Minor == 0)
return VersionTuple(Major);
if (Subminor == 0)
return VersionTuple(Major, Minor - 1);
return VersionTuple(Major, Minor - 1, Subminor - 1);
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
const RecordData &Record,
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
unsigned &Idx) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
return CXXTemporary::Create(*Context, Decl);
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
Compare the predefines buffer in the PCH file with the predefines buffer generated for the current translation unit. If they are different, complain and then ignore the PCH file. This effectively checks for all compilation options that somehow would affect preprocessor state (-D, -U, -include, the dreaded -imacros, etc.). When we do accept the PCH file, throw away the contents of the predefines buffer rather than parsing them, since all of the results of that parsing are already stored in the PCH file. This eliminates the ugliness with the redefinition of __builtin_va_list, among other things. llvm-svn: 68838
2009-04-11 07:10:45 +08:00
return Diag(SourceLocation(), DiagID);
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
Refactoring of Diagnostic class. -Move the stuff of Diagnostic related to creating/querying diagnostic IDs into a new DiagnosticIDs class. -DiagnosticIDs can be shared among multiple Diagnostics for multiple translation units. -The rest of the state in Diagnostic object is considered related and tied to one translation unit. -Have Diagnostic point to the SourceManager that is related with. Diagnostic can now accept just a SourceLocation instead of a FullSourceLoc. -Reflect the changes to various interfaces. llvm-svn: 119730
2010-11-19 04:06:41 +08:00
return Diags.Report(Loc, DiagID);
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
}
PCH support for the first batch of statements, including null, compound, case, default, if, switch, and break statements. llvm-svn: 69329
2009-04-17 08:04:06 +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
/// \brief Retrieve the identifier table associated with the
/// preprocessor.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
IdentifierTable &ASTReader::getIdentifierTable() {
Make changes to PCHReader to allow reading a PCH file without having a pre-initialized Preprocessor. -Introduce 'PCHReaderListener' which is an abstract interface for getting various information from the PCHReader. -If PCHReader is constructed without a Preprocessor, it can still load the file and invoke the callbacks of PCHReaderListener. -If PCHReader is constructed with an initialized Preprocessor, PCHValidator is used as a PCHReaderListener to validate the contents of the PCH file against the given Preprocessor. llvm-svn: 73741
2009-06-19 08:03:23 +08:00
assert(PP && "Forgot to set Preprocessor ?");
return PP->getIdentifierTable();
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
}
PCH support for the first batch of statements, including null, compound, case, default, if, switch, and break statements. llvm-svn: 69329
2009-04-17 08:04:06 +08:00
/// \brief Record that the given ID maps to the given switch-case
/// statement.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
PCH support for the first batch of statements, including null, compound, case, default, if, switch, and break statements. llvm-svn: 69329
2009-04-17 08:04:06 +08:00
assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
SwitchCaseStmts[ID] = SC;
}
/// \brief Retrieve the switch-case statement with the given ID.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
PCH support for the first batch of statements, including null, compound, case, default, if, switch, and break statements. llvm-svn: 69329
2009-04-17 08:04:06 +08:00
assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
return SwitchCaseStmts[ID];
}
PCH support for labels and goto. llvm-svn: 69364
2009-04-18 02:18:49 +08:00
Switch case IDs conflict between chained PCHs; since there is no need to be global, make them local to a decl. llvm-svn: 117540
2010-10-28 17:29:32 +08:00
void ASTReader::ClearSwitchCaseIDs() {
SwitchCaseStmts.clear();
}
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
void ASTReader::FinishedDeserializing() {
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
assert(NumCurrentElementsDeserializing &&
"FinishedDeserializing not paired with StartedDeserializing");
if (NumCurrentElementsDeserializing == 1) {
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
// If any identifiers with corresponding top-level declarations have
// been loaded, load those declarations now.
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
while (!PendingIdentifierInfos.empty()) {
SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
PendingIdentifierInfos.front().DeclIDs, true);
PendingIdentifierInfos.pop_front();
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
}
Delay passing InterestingDecls to the Consumer until when we know we are not in recursive loading and the declarations are fully initialized. llvm-svn: 107783
2010-07-07 23:46:26 +08:00
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
// Ready to load previous declarations of Decls that were delayed.
while (!PendingPreviousDecls.empty()) {
loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
PendingPreviousDecls.front().second);
PendingPreviousDecls.pop_front();
}
Delay passing InterestingDecls to the Consumer until when we know we are not in recursive loading and the declarations are fully initialized. llvm-svn: 107783
2010-07-07 23:46:26 +08:00
// We are not in recursive loading, so it's safe to pass the "interesting"
// decls to the consumer.
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
if (Consumer)
PassInterestingDeclsToConsumer();
Simplify and "robust-ify" the way that CXXRecord references point to the definition data when loaded from PCH. Temporary disable 'test/PCH/chain-cxx.cpp' until a better way to fix it is in place. llvm-svn: 117234
2010-10-25 01:26:31 +08:00
assert(PendingForwardRefs.size() == 0 &&
"Some forward refs did not get linked to the definition!");
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
}
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
--NumCurrentElementsDeserializing;
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
}
Make sure to deallocate the identifier lookup tables and selector tables when destroying an ASTReader. Plugs a leak that shows up in libclang. llvm-svn: 111488
2010-08-19 08:28:17 +08:00
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
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, bool DisableValidation,
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
bool DisableStatCache)
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
: Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
RelocatablePCH(false), isysroot(isysroot),
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
DisableValidation(DisableValidation),
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
NumSLocEntriesRead(0), TotalNumSLocEntries(0),
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
Cleaning up more of the ID situation in the AST reader. This patch relaxes and generalizes how CXX base specifiers are identified and loaded by using a ContinuousRangeMap. This also adds a global bit offset (or base) to the PerFileData. llvm-svn: 135705
2011-07-22 05:15:19 +08:00
NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
NumCXXBaseSpecifiersLoaded(0)
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +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
SourceMgr.setExternalSLocEntrySource(this);
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
}
ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
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
Diagnostic &Diags, StringRef isysroot,
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
bool DisableValidation, bool DisableStatCache)
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
: DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
Diags(Diags), SemaObj(0), PP(0), Context(0),
Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
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
RelocatablePCH(false), isysroot(isysroot),
DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
TotalNumSLocEntries(0), NumStatementsRead(0),
TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
Change source manager serialization to be less tied to the PCH model. llvm-svn: 114575
2010-09-23 04:19:08 +08:00
TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
Cleaning up more of the ID situation in the AST reader. This patch relaxes and generalizes how CXX base specifiers are identified and loaded by using a ContinuousRangeMap. This also adds a global bit offset (or base) to the PerFileData. llvm-svn: 135705
2011-07-22 05:15:19 +08:00
TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
{
SourceMgr.setExternalSLocEntrySource(this);
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
}
ASTReader::~ASTReader() {
// Delete all visible decl lookup tables
for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
E = DeclContextOffsets.end();
I != E; ++I) {
for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
J != F; ++J) {
if (J->NameLookupTableData)
delete static_cast<ASTDeclContextNameLookupTable*>(
J->NameLookupTableData);
}
}
for (DeclContextVisibleUpdatesPending::iterator
I = PendingVisibleUpdates.begin(),
E = PendingVisibleUpdates.end();
I != E; ++I) {
for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
F = I->second.end();
J != F; ++J)
delete static_cast<ASTDeclContextNameLookupTable*>(*J);
}
}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module::Module(ModuleKind Kind)
: Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
SLocEntryBaseOffset(0), SLocEntryOffsets(0),
SLocFileOffsets(0), LocalNumIdentifiers(0),
IdentifierOffsets(0), IdentifierTableData(0),
Reshuffle PerFileData's members to make more sense. llvm-svn: 114517
2010-09-22 08:42:27 +08:00
IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
MacroDefinitionOffsets(0), LocalNumHeaderFileInfos(0),
HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
AST serialization support for the Framework in IndexHeaderMapHeader fields of HeaderFileInfo. llvm-svn: 136332
2011-07-28 12:50:02 +08:00
HeaderFileFrameworkStrings(0),
Implement two related optimizations that make de-serialization of AST/PCH files more lazy: - Don't preload all of the file source-location entries when reading the AST file. Instead, load them lazily, when needed. - Only look up header-search information (whether a header was already #import'd, how many times it's been included, etc.) when it's needed by the preprocessor, rather than pre-populating it. Previously, we would pre-load all of the file source-location entries, which also populated the header-search information structure. This was a relatively minor performance issue, since we would end up stat()'ing all of the headers stored within a AST/PCH file when the AST/PCH file was loaded. In the normal PCH use case, the stat()s were cached, so the cost--of preloading ~860 source-location entries in the Cocoa.h case---was relatively low. However, the recent optimization that replaced stat+open with open+fstat turned this into a major problem, since the preloading of source-location entries would now end up opening those files. Worse, those files wouldn't be closed until the file manager was destroyed, so just opening a Cocoa.h PCH file would hold on to ~860 file descriptors, and it was easy to blow through the process's limit on the number of open file descriptors. By eliminating the preloading of these files, we neither open nor stat the headers stored in the PCH/AST file until they're actually needed for something. Concretely, we went from *** HeaderSearch Stats: 835 files tracked. 364 #import/#pragma once files. 823 included exactly once. 6 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 835 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. with a trivial program that uses a chained PCH including a Cocoa PCH to *** HeaderSearch Stats: 4 files tracked. 1 #import/#pragma once files. 3 included exactly once. 2 max times a file is included. 3 #include/#include_next/#import. 0 #includes skipped due to the multi-include optimization. 1 framework lookups. 0 subframework lookups. *** Source Manager Stats: 3 files mapped, 3 mem buffers mapped. 37460 SLocEntry's allocated, 11215575B of Sloc address space used. 62 bytes of files mapped, 0 files with line #'s computed. for the same program. llvm-svn: 125286
2011-02-11 01:09:37 +08:00
LocalNumSelectors(0), SelectorOffsets(0),
Reshuffle PerFileData's members to make more sense. llvm-svn: 114517
2010-09-22 08:42:27 +08:00
SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(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
DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
LocalNumTypes(0), TypeOffsets(0), StatCache(0),
Record module loaders and module source order. llvm-svn: 115334
2010-10-02 03:59:12 +08:00
NumPreallocatedPreprocessingEntities(0), NextInSource(0)
Make sure to deallocate the identifier lookup tables and selector tables when destroying an ASTReader. Plugs a leak that shows up in libclang. llvm-svn: 111488
2010-08-19 08:28:17 +08:00
{}
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
Module::~Module() {
Make sure to deallocate the identifier lookup tables and selector tables when destroying an ASTReader. Plugs a leak that shows up in libclang. llvm-svn: 111488
2010-08-19 08:28:17 +08:00
delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
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
delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
Make sure to deallocate the identifier lookup tables and selector tables when destroying an ASTReader. Plugs a leak that shows up in libclang. llvm-svn: 111488
2010-08-19 08:28:17 +08:00
delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
}
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
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
Module *ModuleManager::lookup(StringRef Name) {
const FileEntry *Entry = FileMgr.getFile(Name);
return Modules[Entry];
}
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
/// \brief Creates a new module and adds it to the list of known modules
Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) {
Module *Prev = !size() ? 0 : &getLastModule();
Module *Current = new Module(Type);
Current->FileName = FileName.str();
Chain.push_back(Current);
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
const FileEntry *Entry = FileMgr.getFile(FileName);
Modules[Entry] = Current;
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
if (Prev)
Prev->NextInSource = Current;
Current->Loaders.push_back(Prev);
return *Current;
}
/// \brief Exports the list of loaded modules with their corresponding names
void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
Target.reserve(size());
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
for (ModuleConstIterator I = Chain.begin(), E = Chain.end();
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
I != E; ++I) {
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset,
(*I)->FileName));
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
}
std::sort(Target.begin(), Target.end());
}
Switch the ModuleManager over to using a FileManager and FileEntry* as part of its lookup instead of the filename. This is a more correct unique identifier, as symlinks can be handled by the FileManager. llvm-svn: 136363
2011-07-29 01:20:23 +08:00
ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { }
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
ModuleManager::~ModuleManager() {
for (unsigned i = 0, e = Chain.size(); i != e; ++i)
delete Chain[e - i - 1];
}