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

3472 lines
120 KiB
C++
Raw Normal View History

Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
//===--- PCHReader.cpp - Precompiled Headers Reader -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the PCHReader class, which reads a precompiled header.
//
//===----------------------------------------------------------------------===//
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +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
#include "clang/Frontend/PCHReader.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"
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
#include "clang/Frontend/PCHDeserializationListener.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"
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 "../Sema/Sema.h" // FIXME: move Sema headers elsewhere
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"
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"
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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"
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"
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"
Use llvm::sys::Path to check isAbsolute, instead of hard coding. Also, remove random FIXME (?). llvm-svn: 89229
2009-11-19 03:50:41 +08:00
#include "llvm/System/Path.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>
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
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
//===----------------------------------------------------------------------===//
// PCH reader validator implementation
//===----------------------------------------------------------------------===//
PCHReaderListener::~PCHReaderListener() {}
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);
PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions);
PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
PARSE_LANGOPT_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);
Check for -fno-constant-cfstrings consistency in pch. llvm-svn: 102130
2010-04-23 05:01:59 +08:00
PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings,
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);
clang -cc1: Add -fsjlj-exceptions, which requires far too much button pushing. llvm-svn: 95785
2010-02-11 02:48:44 +08:00
PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions);
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);
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);
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);
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);
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);
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;
}
StringRefify some PCH interfaces. llvm-svn: 86775
2009-11-11 08:52:11 +08:00
bool PCHValidator::ReadTargetTriple(llvm::StringRef Triple) {
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
}
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
struct EmptyStringRef {
Pass StringRefs by value. llvm-svn: 108375
2010-07-15 07:19:41 +08:00
bool operator ()(llvm::StringRef r) const { return r.empty(); }
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
};
struct EmptyBlock {
bool operator ()(const PCHPredefinesBlock &r) const { return r.Data.empty(); }
};
static bool EqualConcatenations(llvm::SmallVector<llvm::StringRef, 2> L,
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.
llvm::StringRef LR = L[0], RR = R[0].Data;
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;
}
}
}
static std::pair<FileID, llvm::StringRef::size_type>
FindMacro(const PCHPredefinesBlocks &Buffers, llvm::StringRef MacroDef) {
std::pair<FileID, llvm::StringRef::size_type> Res;
for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
Res.second = Buffers[I].Data.find(MacroDef);
if (Res.second != llvm::StringRef::npos) {
Res.first = Buffers[I].BufferID;
break;
}
}
return Res;
}
bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
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::StringRef OriginalFileName,
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 &SuggestedPredefines) {
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 \"";
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
PCHInclude += NormalizeDashIncludePath(OriginalFileName);
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";
std::pair<llvm::StringRef,llvm::StringRef> Split =
llvm::StringRef(PP.getPredefines()).split(PCHInclude.str());
llvm::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.
// We build a SmallVector of the command line here, because we'll eventually
// need to support an arbitrary amount of pieces anyway (when we have chained
// PCH reading).
llvm::SmallVector<llvm::StringRef, 2> CommandLine;
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 local splitLines reimplementation. llvm-svn: 88661
2009-11-14 00:46:11 +08:00
llvm::SmallVector<llvm::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
llvm::SmallVector<llvm::StringRef, 8> CmdLineLines;
Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Right.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
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.
std::vector<llvm::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) {
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
llvm::StringRef Missing = MissingPredefines[I];
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");
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
llvm::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 local splitLines reimplementation. llvm-svn: 88661
2009-11-14 00:46:11 +08:00
llvm::SmallVector<llvm::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.
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
std::pair<FileID, llvm::StringRef::size_type> MacroLoc =
FindMacro(Buffers, Missing);
assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!");
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.
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
std::pair<FileID, llvm::StringRef::size_type> MacroLoc =
FindMacro(Buffers, Missing);
assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!");
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.
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
std::vector<llvm::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) {
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
llvm::StringRef &Extra = ExtraPredefines[I];
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");
More StringRef simplification to PCHValidator::ReadPredefinesBuffer. llvm-svn: 86805
2009-11-11 13:26:28 +08:00
llvm::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
//===----------------------------------------------------------------------===//
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
// PCH reader implementation
//===----------------------------------------------------------------------===//
Add PCH read/write support for ObjC statements. llvm-svn: 70143
2009-04-27 02:52:16 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCHReader::PCHReader(Preprocessor &PP, ASTContext *Context,
const char *isysroot)
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
: Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
StatCache(0), Consumer(0), IdentifierTableData(0), IdentifierLookupTable(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
IdentifierOffsets(0),
MethodPoolLookupTable(0), MethodPoolLookupTableData(0),
TotalSelectorsInMethodPool(0), SelectorOffsets(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
TotalNumSelectors(0), MacroDefinitionOffsets(0),
Remove the capture, serialization, and deserialization of comment ranges as part of the ASTContext. This code is not and was never used, but contributes ~250k to the size of the Cocoa.h precompiled header. llvm-svn: 99007
2010-03-20 06:13:20 +08:00
NumPreallocatedPreprocessingEntities(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
isysroot(isysroot), NumStatHits(0), NumStatMisses(0),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
NumSLocEntriesRead(0), NumStatementsRead(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
NumMacrosRead(0), NumMethodPoolSelectorsRead(0), NumMethodPoolMisses(0),
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
NumLexicalDeclContextsRead(0), NumVisibleDeclContextsRead(0),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
CurrentlyLoadingTypeOrDecl(0) {
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
RelocatablePCH = false;
}
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
PCHReader::PCHReader(SourceManager &SourceMgr, FileManager &FileMgr,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Diagnostic &Diags, const char *isysroot)
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
: DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
Diags(Diags), SemaObj(0), PP(0), Context(0), StatCache(0), Consumer(0),
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
IdentifierTableData(0), IdentifierLookupTable(0),
IdentifierOffsets(0),
MethodPoolLookupTable(0), MethodPoolLookupTableData(0),
TotalSelectorsInMethodPool(0), SelectorOffsets(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
TotalNumSelectors(0), MacroDefinitionOffsets(0),
Remove the capture, serialization, and deserialization of comment ranges as part of the ASTContext. This code is not and was never used, but contributes ~250k to the size of the Cocoa.h precompiled header. llvm-svn: 99007
2010-03-20 06:13:20 +08:00
NumPreallocatedPreprocessingEntities(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
isysroot(isysroot), NumStatHits(0), NumStatMisses(0),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
NumSLocEntriesRead(0), NumStatementsRead(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
NumMacrosRead(0), NumMethodPoolSelectorsRead(0), NumMethodPoolMisses(0),
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
NumLexicalDeclContextsRead(0), NumVisibleDeclContextsRead(0),
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
CurrentlyLoadingTypeOrDecl(0) {
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
RelocatablePCH = false;
}
Add PCH read/write support for ObjC statements. llvm-svn: 70143
2009-04-27 02:52:16 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
PCHReader::~PCHReader() {}
Add PCH read/write support for ObjC statements. llvm-svn: 70143
2009-04-27 02:52:16 +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
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 {
Remove VISIBILITY_HIDDEN from anonymous namespaces in libFrontend. llvm-svn: 90033
2009-11-28 18:07:24 +08:00
class PCHMethodPoolLookupTrait {
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
PCHReader &Reader;
public:
typedef std::pair<ObjCMethodList, ObjCMethodList> data_type;
typedef Selector external_key_type;
typedef external_key_type internal_key_type;
explicit PCHMethodPoolLookupTrait(PCHReader &Reader) : Reader(Reader) { }
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) {
unsigned N = Sel.getNumArgs();
if (N == 0)
++N;
unsigned R = 5381;
for (unsigned I = 0; I != N; ++I)
if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(I))
Switch to llvm::HashString. llvm-svn: 84375
2009-10-18 07:52:28 +08:00
R = llvm::HashString(II->getName(), R);
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
return R;
}
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
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
= Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
if (N == 0)
return SelTable.getNullarySelector(FirstII);
else if (N == 1)
return SelTable.getUnarySelector(FirstII);
llvm::SmallVector<IdentifierInfo *, 16> Args;
Args.push_back(FirstII);
for (unsigned I = 1; I != N; ++I)
Args.push_back(Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)));
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;
unsigned NumInstanceMethods = ReadUnalignedLE16(d);
unsigned NumFactoryMethods = ReadUnalignedLE16(d);
data_type Result;
// 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
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
= cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d)));
if (!Result.first.Method) {
// This is the first method, which is the easy case.
Result.first.Method = Method;
Prev = &Result.first;
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
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
= cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d)));
if (!Result.second.Method) {
// This is the first method, which is the easy case.
Result.second.Method = Method;
Prev = &Result.second;
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.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
typedef OnDiskChainedHashTable<PCHMethodPoolLookupTrait>
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
PCHMethodPoolLookupTable;
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
namespace {
Remove VISIBILITY_HIDDEN from anonymous namespaces in libFrontend. llvm-svn: 90033
2009-11-28 18:07:24 +08:00
class PCHIdentifierLookupTrait {
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
PCHReader &Reader;
// If we know the IdentifierInfo in advance, it is here and we will
// not build a new one. Used when deserializing information about an
// identifier that was constructed before the PCH file was read.
IdentifierInfo *KnownII;
public:
typedef IdentifierInfo * data_type;
typedef const std::pair<const char*, unsigned> external_key_type;
typedef external_key_type internal_key_type;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
explicit PCHIdentifierLookupTrait(PCHReader &Reader, IdentifierInfo *II = 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
: Reader(Reader), 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) {
Switch to llvm::HashString. llvm-svn: 84375
2009-10-18 07:52:28 +08:00
return llvm::HashString(llvm::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
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;
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
pch::IdentID ID = ReadUnalignedLE32(d);
bool IsInteresting = ID & 0x01;
// Wipe out the "is interesting" bit.
ID = ID >> 1;
if (!IsInteresting) {
// For unintersting identifiers, just build the IdentifierInfo
// and associate it with the persistent ID.
IdentifierInfo *II = KnownII;
if (!II)
II = &Reader.getIdentifierTable().CreateIdentifierInfo(
k.first, k.first + k.second);
Reader.SetIdentifierInfo(ID, II);
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;
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)
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
II = &Reader.getIdentifierTable().CreateIdentifierInfo(
k.first, k.first + 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.
// FIXME: Load token IDs lazily, too?
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);
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
Reader.ReadMacroRecord(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) {
llvm::SmallVector<uint32_t, 4> DeclIDs;
for (; DataLen > 0; DataLen -= 4)
DeclIDs.push_back(ReadUnalignedLE32(d));
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
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.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
typedef OnDiskChainedHashTable<PCHIdentifierLookupTrait>
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
PCHIdentifierLookupTable;
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
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
void PCHReader::Error(const char *Msg) {
Diag(diag::err_fe_pch_malformed) << Msg;
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 PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
/// \brief Check the contents of the concatenation of all predefines buffers in
/// the PCH chain against the contents of the predefines buffer of the current
/// compiler invocation.
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
///
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
/// The contents should be the same. If not, then some command-line option
/// changed the preprocessor state and we must probably reject the PCH 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
///
/// \returns true if there was a mismatch (in which case the PCH file
/// should be ignored), or false otherwise.
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
bool PCHReader::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,
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
SuggestedPredefines);
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.
/// \returns true if ther was an error.
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
bool PCHReader::ParseLineTable(llvm::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);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(),
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
Filename.size());
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++];
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 {
Remove VISIBILITY_HIDDEN from anonymous namespaces in libFrontend. llvm-svn: 90033
2009-11-28 18:07:24 +08:00
class PCHStatData {
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 bool hasStat;
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
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
PCHStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
: hasStat(true), 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
PCHStatData()
: hasStat(false), ino(0), dev(0), mode(0), mtime(0), size(0) {}
};
Remove VISIBILITY_HIDDEN from anonymous namespaces in libFrontend. llvm-svn: 90033
2009-11-28 18:07:24 +08:00
class PCHStatLookupTrait {
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;
typedef PCHStatData data_type;
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;
if (*d++ == 1)
return data_type();
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.
Remove VISIBILITY_HIDDEN from anonymous namespaces in libFrontend. llvm-svn: 90033
2009-11-28 18:07:24 +08:00
class PCHStatCache : public StatSysCallCache {
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
typedef OnDiskChainedHashTable<PCHStatLookupTrait> CacheTy;
CacheTy *Cache;
unsigned &NumStatHits, &NumStatMisses;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
public:
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
PCHStatCache(const unsigned char *Buckets,
const unsigned char *Base,
unsigned &NumStatHits,
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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);
}
~PCHStatCache() { delete Cache; }
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
int stat(const char *path, struct stat *buf) {
// Do the lookup for the file's data in the PCH file.
CacheTy::iterator I = Cache->find(path);
// If we don't get a hit in the PCH file just forward to 'stat'.
if (I == Cache->end()) {
++NumStatMisses;
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
return StatSysCallCache::stat(path, buf);
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;
PCHStatData Data = *I;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement caching of stat() calls for precompiled headers, which is essentially the same thing we do with pretokenized headers. stat() caching improves performance of the Cocoa-prefixed "Hello, World" by 45%. llvm-svn: 70223
2009-04-28 02:38:38 +08:00
if (!Data.hasStat)
return 1;
buf->st_ino = Data.ino;
buf->st_dev = Data.dev;
buf->st_mtime = Data.mtime;
buf->st_mode = Data.mode;
buf->st_size = Data.size;
return 0;
}
};
} // end anonymous namespace
PCH serialization/deserialization of the source manager. With this improvement, source locations read from the PCH file will properly resolve to the source files that were used to build the PCH file itself. Once we have the preprocessor state stored in the PCH file, source locations that refer to macro instantiations that occur in the PCH file should have the appropriate instantiation information. llvm-svn: 68758
2009-04-10 11:52:48 +08:00
/// \brief Read the source manager block
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
PCHReader::PCHReadResult PCHReader::ReadSourceManagerBlock() {
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
// 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.
SLocEntryCursor = Stream;
// The stream itself is going to skip over the source manager block.
if (Stream.SkipBlock()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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.
if (SLocEntryCursor.EnterSubBlock(pch::SOURCE_MANAGER_BLOCK_ID)) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed source manager block record in PCH 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()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("error at end of Source Manager block in PCH 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()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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;
Change Lexer::MeasureTokenLength to take a LangOptions reference. This allows it to accurately measure tokens, so that we get: t.cpp:8:13: error: unknown type name 'X' static foo::X P; ~~~~~^ instead of the woefully inferior: t.cpp:8:13: error: unknown type name 'X' static foo::X P; ~~~~ ^ Most of this is just plumbing to push the reference around. llvm-svn: 69099
2009-04-15 07:22:57 +08:00
case pch::SM_LINE_TABLE:
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 (ParseLineTable(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
return Failure;
Change Lexer::MeasureTokenLength to take a LangOptions reference. This allows it to accurately measure tokens, so that we get: t.cpp:8:13: error: unknown type name 'X' static foo::X P; ~~~~~^ instead of the woefully inferior: t.cpp:8:13: error: unknown type name 'X' static foo::X P; ~~~~ ^ Most of this is just plumbing to push the reference around. llvm-svn: 69099
2009-04-15 07:22:57 +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
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
case pch::SM_SLOC_FILE_ENTRY:
case pch::SM_SLOC_BUFFER_ENTRY:
case pch::SM_SLOC_INSTANTIATION_ENTRY:
// 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
}
}
}
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.
PCHReader::PCHReadResult PCHReader::ReadSLocEntryRecord(unsigned ID) {
if (ID == 0)
return Success;
if (ID > TotalNumSLocEntries) {
Error("source location entry ID out-of-range for PCH file");
return Failure;
}
++NumSLocEntriesRead;
SLocEntryCursor.JumpToBit(SLocOffsets[ID - 1]);
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 PCH 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 PCH file");
return Failure;
case pch::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);
const FileEntry *File = FileMgr.getFile(Filename);
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;
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
ErrorStr += "' referenced by PCH file";
Error(ErrorStr.c_str());
return Failure;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Keep track of the size/modification time of each file source-location entry in a precompiled header, so that we can detect modified files even when we miss in the stat cache. llvm-svn: 99149
2010-03-22 06:49:54 +08:00
if (Record.size() < 10) {
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;
}
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 ((off_t)Record[4] != File->getSize()
#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] != File->getModificationTime()
#endif
) {
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
Diag(diag::err_fe_pch_file_modified)
<< Filename;
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
FileID FID = SourceMgr.createFileID(File,
SourceLocation::getFromRawEncoding(Record[1]),
(SrcMgr::CharacteristicKind)Record[2],
ID, Record[0]);
if (Record[3])
const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile())
.setHasLineDirectives();
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
// Reconstruct header-search information for this file.
HeaderFileInfo HFI;
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
HFI.isImport = Record[6];
HFI.DirInfo = Record[7];
HFI.NumIncludes = Record[8];
HFI.ControllingMacroID = Record[9];
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
if (Listener)
Listener->ReadHeaderFileInfo(HFI, File->getUID());
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;
}
case pch::SM_SLOC_BUFFER_ENTRY: {
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
if (RecCode != pch::SM_SLOC_BUFFER_BLOB) {
Error("PCH record has invalid code");
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
Match MemoryBuffer API changes. llvm-svn: 100484
2010-04-06 06:42:27 +08:00
= llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(BlobStart, BlobLen - 1),
Name);
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
FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, 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,
llvm::StringRef(BlobStart, BlobLen - 1)
};
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;
}
case pch::SM_SLOC_INSTANTIATION_ENTRY: {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SourceLocation SpellingLoc
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
= SourceLocation::getFromRawEncoding(Record[1]);
SourceMgr.createInstantiationLoc(SpellingLoc,
SourceLocation::getFromRawEncoding(Record[2]),
SourceLocation::getFromRawEncoding(Record[3]),
Record[4],
ID,
Record[0]);
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;
}
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.
bool PCHReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
unsigned BlockID) {
if (Cursor.EnterSubBlock(BlockID)) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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) {
unsigned Code = Cursor.ReadCode();
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
// We expect all abbrevs to be at the start of the block.
if (Code != llvm::bitc::DEFINE_ABBREV)
return false;
Cursor.ReadAbbrevRecord();
}
}
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
void PCHReader::ReadMacroRecord(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 ?");
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;
llvm::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:
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
return;
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()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH file");
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
return;
}
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.
Record.clear();
pch::PreprocessorRecordTypes RecType =
(pch::PreprocessorRecordTypes)Stream.ReadRecord(Code, Record);
switch (RecType) {
case pch::PP_MACRO_OBJECT_LIKE:
case pch::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)
return;
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
IdentifierInfo *II = DecodeIdentifierInfo(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) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("macro must have a name in PCH file");
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
return;
}
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
SourceLocation Loc = SourceLocation::getFromRawEncoding(Record[1]);
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);
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;
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
if (RecType == pch::PP_MACRO_FUNCTION_LIKE) {
// Decode function-like macro info.
bool isC99VarArgs = Record[3];
bool isGNUVarArgs = Record[4];
MacroArgs.clear();
unsigned NumArgs = Record[5];
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)
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
MacroArgs.push_back(DecodeIdentifierInfo(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;
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,
getMacroDefinition(Record[NextIndex]));
}
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
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 pch::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();
Tok.setLocation(SourceLocation::getFromRawEncoding(Record[0]));
Tok.setLength(Record[1]);
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
if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2]))
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;
}
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
case pch::PP_MACRO_INSTANTIATION: {
// 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)
return;
if (!PP->getPreprocessingRecord()) {
Error("missing preprocessing record in PCH file");
return;
}
PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
if (PPRec.getPreprocessedEntity(Record[0]))
return;
MacroInstantiation *MI
= new (PPRec) MacroInstantiation(DecodeIdentifierInfo(Record[3]),
SourceRange(
SourceLocation::getFromRawEncoding(Record[1]),
SourceLocation::getFromRawEncoding(Record[2])),
getMacroDefinition(Record[4]));
PPRec.SetPreallocatedEntity(Record[0], MI);
return;
}
case pch::PP_MACRO_DEFINITION: {
// 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)
return;
if (!PP->getPreprocessingRecord()) {
Error("missing preprocessing record in PCH file");
return;
}
PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
if (PPRec.getPreprocessedEntity(Record[0]))
return;
if (Record[1] >= MacroDefinitionsLoaded.size()) {
Error("out-of-bounds macro definition record");
return;
}
MacroDefinition *MD
= new (PPRec) MacroDefinition(DecodeIdentifierInfo(Record[4]),
SourceLocation::getFromRawEncoding(Record[5]),
SourceRange(
SourceLocation::getFromRawEncoding(Record[2]),
SourceLocation::getFromRawEncoding(Record[3])));
PPRec.SetPreallocatedEntity(Record[0], MD);
MacroDefinitionsLoaded[Record[1]] = MD;
return;
}
Add PCH support for #import. llvm-svn: 69987
2009-04-25 04:03:17 +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
}
}
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
void PCHReader::ReadDefinedMacros() {
// If there was no preprocessor block, do nothing.
if (!MacroCursor.getBitStreamReader())
return;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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
llvm::BitstreamCursor Cursor = MacroCursor;
if (Cursor.EnterSubBlock(pch::PREPROCESSOR_BLOCK_ID)) {
Error("malformed preprocessor block record in PCH file");
return;
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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
RecordData Record;
while (true) {
unsigned Code = Cursor.ReadCode();
if (Code == llvm::bitc::END_BLOCK) {
if (Cursor.ReadBlockEnd())
Error("error at end of preprocessor block in PCH file");
return;
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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 (Code == llvm::bitc::ENTER_SUBBLOCK) {
// No known subblocks, always skip them.
Cursor.ReadSubBlockID();
if (Cursor.SkipBlock()) {
Error("malformed block record in PCH file");
return;
}
continue;
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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 (Code == llvm::bitc::DEFINE_ABBREV) {
Cursor.ReadAbbrevRecord();
continue;
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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
// Read a record.
const char *BlobStart;
unsigned BlobLen;
Record.clear();
switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
default: // Default behavior: ignore.
break;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
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
case pch::PP_MACRO_OBJECT_LIKE:
case pch::PP_MACRO_FUNCTION_LIKE:
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
DecodeIdentifierInfo(Record[0]);
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
break;
case pch::PP_TOKEN:
// Ignore tokens.
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
case pch::PP_MACRO_INSTANTIATION:
case pch::PP_MACRO_DEFINITION:
// Read the macro record.
ReadMacroRecord(Cursor.GetCurrentBitNo());
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
}
}
}
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
MacroDefinition *PCHReader::getMacroDefinition(pch::IdentID ID) {
if (ID == 0 || ID >= MacroDefinitionsLoaded.size())
return 0;
if (!MacroDefinitionsLoaded[ID])
ReadMacroRecord(MacroDefinitionOffsets[ID]);
return MacroDefinitionsLoaded[ID];
}
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.
void PCHReader::MaybeAddSystemRootToFilename(std::string &Filename) {
// 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
Use llvm::sys::Path to check isAbsolute, instead of hard coding. Also, remove random FIXME (?). llvm-svn: 89229
2009-11-19 03:50:41 +08:00
if (Filename.empty() || llvm::sys::Path(Filename).isAbsolute())
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;
if (isysroot == 0) {
// 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
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
unsigned Length = strlen(isysroot);
if (isysroot[Length - 1] != '/')
Filename.insert(Filename.begin(), '/');
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the notion of "Relocatable" precompiled headers, which are built with a particular system root directory and can be used with a different system root directory when the headers it depends on have been installed. Relocatable precompiled headers rewrite the file names of the headers used when generating the PCH file into the corresponding file names of the headers available when using the PCH file. Addresses <rdar://problem/7001604>. llvm-svn: 74885
2009-07-07 08:12:59 +08:00
Filename.insert(Filename.begin(), isysroot, isysroot + Length);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCHReader::PCHReadResult
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
PCHReader::ReadPCHBlock() {
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.EnterSubBlock(pch::PCH_BLOCK_ID)) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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
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 all of the records and blocks for the PCH 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;
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()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("error at end of module block in PCH 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()) {
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
case pch::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.
DeclsCursor = Stream;
if (Stream.SkipBlock() || // Skip with the main cursor.
// Read the abbrevs.
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
ReadBlockAbbrevs(DeclsCursor, pch::DECLTYPES_BLOCK_ID)) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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
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
case pch::PREPROCESSOR_BLOCK_ID:
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
MacroCursor = Stream;
if (PP)
PP->setExternalSource(this);
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
if (Stream.SkipBlock()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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;
}
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
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
case pch::SOURCE_MANAGER_BLOCK_ID:
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
switch (ReadSourceManagerBlock()) {
case Success:
break;
case Failure:
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed source manager block in PCH 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;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
switch ((pch::PCHRecordTypes)Stream.ReadRecord(Code, Record,
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
&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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 pch::TYPE_OFFSET:
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()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate TYPE_OFFSET record in PCH 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;
}
encode the type and decl offsets with 32-bits for entry instead of 64 bits. This cuts 400KB off the PCH file for cocoa (7.1 -> 6.7MB): Before: Record Histogram: Count # Bits % Abv Record Kind 1 14296 SOURCE_LOCATION_PRELOADS 1 1699598 100.00 SOURCE_LOCATION_OFFSETS 1 1870766 100.00 METHOD_POOL 1 212988 100.00 SELECTOR_OFFSETS 1 88 STATISTICS 1 106 SPECIAL_TYPES 1 18033788 100.00 IDENTIFIER_TABLE 1 1806428 100.00 IDENTIFIER_OFFSET 1 170 100.00 TARGET_TRIPLE 1 268 LANGUAGE_OPTIONS 1 5168252 100.00 DECL_OFFSET 1 952700 100.00 TYPE_OFFSET After: Record Histogram: Count # Bits % Abv Record Kind 1 14296 SOURCE_LOCATION_PRELOADS 1 1699598 100.00 SOURCE_LOCATION_OFFSETS 1 1870766 100.00 METHOD_POOL 1 212988 100.00 SELECTOR_OFFSETS 1 88 STATISTICS 1 106 SPECIAL_TYPES 1 18033788 100.00 IDENTIFIER_TABLE 1 1806428 100.00 IDENTIFIER_OFFSET 1 170 100.00 TARGET_TRIPLE 1 268 LANGUAGE_OPTIONS 1 2584156 100.00 DECL_OFFSET 1 476380 100.00 TYPE_OFFSET llvm-svn: 70216
2009-04-28 02:24:17 +08:00
TypeOffsets = (const uint32_t *)BlobStart;
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
TypesLoaded.resize(Record[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
break;
case pch::DECL_OFFSET:
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 (!DeclsLoaded.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate DECL_OFFSET record in PCH 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;
}
encode the type and decl offsets with 32-bits for entry instead of 64 bits. This cuts 400KB off the PCH file for cocoa (7.1 -> 6.7MB): Before: Record Histogram: Count # Bits % Abv Record Kind 1 14296 SOURCE_LOCATION_PRELOADS 1 1699598 100.00 SOURCE_LOCATION_OFFSETS 1 1870766 100.00 METHOD_POOL 1 212988 100.00 SELECTOR_OFFSETS 1 88 STATISTICS 1 106 SPECIAL_TYPES 1 18033788 100.00 IDENTIFIER_TABLE 1 1806428 100.00 IDENTIFIER_OFFSET 1 170 100.00 TARGET_TRIPLE 1 268 LANGUAGE_OPTIONS 1 5168252 100.00 DECL_OFFSET 1 952700 100.00 TYPE_OFFSET After: Record Histogram: Count # Bits % Abv Record Kind 1 14296 SOURCE_LOCATION_PRELOADS 1 1699598 100.00 SOURCE_LOCATION_OFFSETS 1 1870766 100.00 METHOD_POOL 1 212988 100.00 SELECTOR_OFFSETS 1 88 STATISTICS 1 106 SPECIAL_TYPES 1 18033788 100.00 IDENTIFIER_TABLE 1 1806428 100.00 IDENTIFIER_OFFSET 1 170 100.00 TARGET_TRIPLE 1 268 LANGUAGE_OPTIONS 1 2584156 100.00 DECL_OFFSET 1 476380 100.00 TYPE_OFFSET llvm-svn: 70216
2009-04-28 02:24:17 +08:00
DeclOffsets = (const uint32_t *)BlobStart;
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
DeclsLoaded.resize(Record[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
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
case pch::LANGUAGE_OPTIONS:
if (ParseLanguageOptions(Record))
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
Add a header containing the Clang version; make the driver use this Clang version value rather than hard-coding "1.0". Add PCH and Clang version information into the PCH file. Reject PCH files with the wrong version information. llvm-svn: 70264
2009-04-28 06:23:34 +08:00
case pch::METADATA: {
if (Record[0] != pch::VERSION_MAJOR) {
Diag(Record[0] < pch::VERSION_MAJOR? diag::warn_pch_version_too_old
: diag::warn_pch_version_too_new);
return IgnorePCH;
}
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
RelocatablePCH = Record[4];
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) {
std::string TargetTriple(BlobStart, BlobLen);
if (Listener->ReadTargetTriple(TargetTriple))
return IgnorePCH;
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
}
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
}
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
case pch::IDENTIFIER_TABLE:
Lazy deserialization of the declaration chains associated with identifiers from a precompiled header. This patch changes the primary name lookup method for entities within a precompiled header. Previously, we would load all of the names of declarations at translation unit scope into a large DenseMap (inside the TranslationUnitDecl's DeclContext), and then perform a special "last resort" lookup into this DeclContext when we knew there was a PCH file (see Sema::LookupName). Now, when we see an identifier named for the first time, we load all of the declarations with that name that are visible from the translation unit into the IdentifierInfo's chain of declarations. Thus, the explicit "look into the translation unit's DeclContext" code is gone, and Sema effectively uses the same IdentifierInfo-based name lookup mechanism whether we are using a PCH file or not. This approach should help PCH scale with the size of the input program rather than the size of the PCH file. The "Hello, World!" application with Carbon.h as a PCH file now loads 20% of the identifiers in the PCH file rather than 85% of the identifiers. 90% of the 20% of identifiers loaded are actually loaded when we deserialize the preprocessor state. The next step is to make the preprocessor load macros lazily, which should drastically reduce the number of types, declarations, and identifiers loaded for "Hello, World". llvm-svn: 69737
2009-04-22 06:25:48 +08:00
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]) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IdentifierLookupTable
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
= PCHIdentifierLookupTable::Create(
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 *)IdentifierTableData + Record[0],
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
(const unsigned char *)IdentifierTableData,
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
PCHIdentifierLookupTrait(*this));
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)
PP->getIdentifierTable().setExternalIdentifierLookup(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;
case pch::IDENTIFIER_OFFSET:
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
if (!IdentifiersLoaded.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate IDENTIFIER_OFFSET record in PCH 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;
}
Write the identifier offsets array into the PCH file as a blob, so that the PCH reader does not have to decode the VBR encoding at PCH load time. Also, reduce the size of the identifier offsets from 64 bits down to 32 bits. The identifier table itself isn't going to grow to more than 4GB :) Overall, this results in a 13% speedup in the Cocoa-prefixed "Hello, World" benchmark. llvm-svn: 70063
2009-04-26 03:10:14 +08:00
IdentifierOffsets = (const uint32_t *)BlobStart;
IdentifiersLoaded.resize(Record[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
if (PP)
PP->getHeaderSearchInfo().SetExternalLookup(this);
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
case pch::EXTERNAL_DEFINITIONS:
if (!ExternalDefinitions.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate EXTERNAL_DEFINITIONS record in PCH file");
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
return Failure;
}
ExternalDefinitions.swap(Record);
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
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
case pch::SPECIAL_TYPES:
SpecialTypes.swap(Record);
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
case pch::STATISTICS:
TotalNumStatements = 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
TotalNumMacros = Record[1];
Add PCH statistics for the number/percent of lexical/visible declcontexts read llvm-svn: 69835
2009-04-23 06:34:57 +08:00
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
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
case pch::TENTATIVE_DEFINITIONS:
if (!TentativeDefinitions.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate TENTATIVE_DEFINITIONS record in PCH file");
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
return Failure;
}
TentativeDefinitions.swap(Record);
break;
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
Implementing unused function warning. llvm-svn: 95940
2010-02-12 08:07:30 +08:00
case pch::UNUSED_STATIC_FUNCS:
if (!UnusedStaticFuncs.empty()) {
Error("duplicate UNUSED_STATIC_FUNCS record in PCH file");
return Failure;
}
UnusedStaticFuncs.swap(Record);
break;
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
case pch::LOCALLY_SCOPED_EXTERNAL_DECLS:
if (!LocallyScopedExternalDecls.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate LOCALLY_SCOPED_EXTERNAL_DECLS record in PCH file");
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
return Failure;
}
LocallyScopedExternalDecls.swap(Record);
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
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
case pch::SELECTOR_OFFSETS:
SelectorOffsets = (const uint32_t *)BlobStart;
TotalNumSelectors = Record[0];
SelectorsLoaded.resize(TotalNumSelectors);
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
case pch::METHOD_POOL:
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
MethodPoolLookupTableData = (const unsigned char *)BlobStart;
if (Record[0])
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
MethodPoolLookupTable
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
= PCHMethodPoolLookupTable::Create(
MethodPoolLookupTableData + Record[0],
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
MethodPoolLookupTableData,
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
PCHMethodPoolLookupTrait(*this));
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
TotalSelectorsInMethodPool = 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
case pch::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
case pch::SOURCE_LOCATION_OFFSETS:
shrink SOURCE_LOCATION_OFFSETS to use 4-byte entries instead of 8-byte entries, shaving 100K off the PCH file for cocoa. llvm-svn: 70228
2009-04-28 03:01:47 +08:00
SLocOffsets = (const uint32_t *)BlobStart;
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
TotalNumSLocEntries = Record[0];
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
SourceMgr.PreallocateSLocEntries(this, TotalNumSLocEntries, Record[1]);
Load most of the source manager's information lazily from the PCH file. In particular, only eagerly load source location entries for files and for the predefines buffer. Other buffers and macro-instantiation source location entries are loaded lazily. With the Cocoa-prefixed "Hello, World", we only load 815/26555 source location entities. This halves the amount of user time we spend in this "Hello, World" program with -fsyntax-only (down to .007s). This optimization is part 1 of 2 for the source manager. This eliminates most of the user time in loading a PCH file. We still spend too much time initialize File structures (especially in the calls to stat), so we need to either make the loading of source location entries for files lazy or import the stat cache from the PTH implementation. llvm-svn: 70196
2009-04-27 14:38:32 +08:00
break;
case pch::SOURCE_LOCATION_PRELOADS:
for (unsigned I = 0, N = Record.size(); I != N; ++I) {
PCHReadResult Result = ReadSLocEntryRecord(Record[I]);
if (Result != Success)
return Result;
}
break;
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
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
case pch::STAT_CACHE: {
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
PCHStatCache *MyStatCache =
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
new PCHStatCache((const unsigned char *)BlobStart + Record[0],
(const unsigned char *)BlobStart,
NumStatHits, NumStatMisses);
FileMgr.addStatCache(MyStatCache);
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
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
case pch::EXT_VECTOR_DECLS:
if (!ExtVectorDecls.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("duplicate EXT_VECTOR_DECLS record in PCH file");
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
return Failure;
}
ExtVectorDecls.swap(Record);
break;
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
case pch::VTABLE_USES:
if (!VTableUses.empty()) {
Error("duplicate VTABLE_USES record in PCH file");
return Failure;
}
VTableUses.swap(Record);
break;
case pch::DYNAMIC_CLASSES:
if (!DynamicClasses.empty()) {
Error("duplicate DYNAMIC_CLASSES record in PCH file");
return Failure;
}
DynamicClasses.swap(Record);
break;
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
case pch::ORIGINAL_FILE_NAME:
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
Rename pch::SVN_BRANCH_REVISION to pch::VERSION_CONTROL_BRANCH_REVISION. llvm-svn: 94214
2010-01-23 04:59:36 +08:00
case pch::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();
Rename getClangSubversionPath() -> getClangRepositoryPath() and have it return a StringRef. llvm-svn: 94213
2010-01-23 04:55:35 +08:00
llvm::StringRef PCHBranch(BlobStart, BlobLen);
Fix bug I introduced with assinging a temporary to a StringRef. llvm-svn: 96041
2010-02-13 07:31:14 +08:00
if (llvm::StringRef(CurBranch) != PCHBranch) {
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
Diag(diag::warn_pch_different_branch) << PCHBranch << CurBranch;
return IgnorePCH;
}
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
case pch::MACRO_DEFINITION_OFFSETS:
MacroDefinitionOffsets = (const uint32_t *)BlobStart;
if (PP) {
if (!PP->getPreprocessingRecord())
PP->createPreprocessingRecord();
PP->getPreprocessingRecord()->SetExternalSource(*this, Record[0]);
} else {
NumPreallocatedPreprocessingEntities = Record[0];
}
MacroDefinitionsLoaded.resize(Record[1]);
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
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("premature end of bitstream in PCH 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
}
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
PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) {
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
// Set the PCH file name.
this->FileName = FileName;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Open the PCH file.
Allow PCH files to be read from stdin. llvm-svn: 82525
2009-09-22 13:38:01 +08:00
//
// FIXME: This shouldn't be here, we should just take a raw_ostream.
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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::string ErrStr;
Switch to getFileOrSTDIN(). llvm-svn: 86632
2009-11-10 08:46:19 +08:00
Buffer.reset(llvm::MemoryBuffer::getFileOrSTDIN(FileName, &ErrStr));
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
if (!Buffer) {
Error(ErrStr.c_str());
return IgnorePCH;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Initialize the stream
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
Adjust to LLVM API changes that went into r70157. llvm-svn: 70158
2009-04-27 04:59:20 +08:00
(const unsigned char *)Buffer->getBufferEnd());
Stream.init(StreamFile);
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Sniff for the signature.
if (Stream.Read(8) != 'C' ||
Stream.Read(8) != 'P' ||
Stream.Read(8) != 'C' ||
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
Stream.Read(8) != 'H') {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Diag(diag::err_not_a_pch_file) << FileName;
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
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
while (!Stream.AtEndOfStream()) {
unsigned Code = Stream.ReadCode();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
if (Code != llvm::bitc::ENTER_SUBBLOCK) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("invalid record at top-level of PCH 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;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 BlockID = Stream.ReadSubBlockID();
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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// We only know the PCH subblock ID.
switch (BlockID) {
case llvm::bitc::BLOCKINFO_BLOCK_ID:
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
if (Stream.ReadBlockInfoBlock()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed BlockInfoBlock in PCH 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;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
break;
case pch::PCH_BLOCK_ID:
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
switch (ReadPCHBlock()) {
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
case Success:
break;
case 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
return Failure;
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
case IgnorePCH:
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
// FIXME: We could consider reading through to the end of this
// PCH block, skipping subblocks, to see if there are other
// PCH blocks elsewhere.
Be more careful in our teardown of the PCHReader after deciding to ignore a PCH file. llvm-svn: 70251
2009-04-28 05:28:04 +08:00
// Clear out any preallocated source location entries, so that
// the source manager does not try to resolve them later.
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
SourceMgr.ClearPreallocatedSLocEntries();
Be more careful in our teardown of the PCHReader after deciding to ignore a PCH file. llvm-svn: 70251
2009-04-28 05:28:04 +08:00
// Remove the stat cache.
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
if (StatCache)
FileMgr.removeStatCache((PCHStatCache*)StatCache);
Be more careful in our teardown of the PCHReader after deciding to ignore a PCH file. llvm-svn: 70251
2009-04-28 05:28:04 +08:00
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 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
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
default:
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
if (Stream.SkipBlock()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH 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;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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;
}
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
// Check the predefines buffer.
Make PCHReader cope with PCH files containing more than one predefines buffer. llvm-svn: 108340
2010-07-15 01:49:11 +08:00
if (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
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
// PCH file is read, so there may be some identifiers that were
// 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.
llvm::SmallVector<IdentifierInfo *, 128> Identifiers;
for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
IdEnd = PP->getIdentifierTable().end();
Id != IdEnd; ++Id)
Identifiers.push_back(Id->second);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCHIdentifierLookupTable *IdTable
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
= (PCHIdentifierLookupTable *)IdentifierLookupTable;
for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
IdentifierInfo *II = Identifiers[I];
// Look in the on-disk hash table for an entry for
PCHIdentifierLookupTrait Info(*this, II);
Move clients to use IdentifierInfo::getNameStart() instead of getName() llvm-svn: 84436
2009-10-19 04:26:12 +08:00
std::pair<const char*, unsigned> Key(II->getNameStart(), II->getLength());
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
PCHIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
if (Pos == IdTable->end())
continue;
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
// Dereferencing the iterator has the effect of populating the
// IdentifierInfo node with the various declarations it needs.
(void)*Pos;
}
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
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
}
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
void PCHReader::setPreprocessor(Preprocessor &pp) {
PP = &pp;
if (NumPreallocatedPreprocessingEntities) {
if (!PP->getPreprocessingRecord())
PP->createPreprocessingRecord();
PP->getPreprocessingRecord()->SetExternalSource(*this,
NumPreallocatedPreprocessingEntities);
NumPreallocatedPreprocessingEntities = 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
void PCHReader::InitializeContext(ASTContext &Ctx) {
Context = &Ctx;
assert(Context && "Passed null context!");
assert(PP && "Forgot to set Preprocessor ?");
PP->getIdentifierTable().setExternalIdentifierLookup(this);
PP->getHeaderSearchInfo().SetExternalLookup(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);
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +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
// 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(
GetType(SpecialTypes[pch::SPECIAL_TYPE_BUILTIN_VA_LIST]));
if (unsigned Id = SpecialTypes[pch::SPECIAL_TYPE_OBJC_ID])
Context->setObjCIdType(GetType(Id));
if (unsigned Sel = SpecialTypes[pch::SPECIAL_TYPE_OBJC_SELECTOR])
Context->setObjCSelType(GetType(Sel));
if (unsigned Proto = SpecialTypes[pch::SPECIAL_TYPE_OBJC_PROTOCOL])
Context->setObjCProtoType(GetType(Proto));
if (unsigned Class = SpecialTypes[pch::SPECIAL_TYPE_OBJC_CLASS])
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
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 (unsigned String = SpecialTypes[pch::SPECIAL_TYPE_CF_CONSTANT_STRING])
Context->setCFConstantStringType(GetType(String));
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (unsigned FastEnum
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
= SpecialTypes[pch::SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
Context->setObjCFastEnumerationStateType(GetType(FastEnum));
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
if (unsigned File = SpecialTypes[pch::SPECIAL_TYPE_FILE]) {
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) {
Error("Invalid FILE type in PCH file");
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());
}
}
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
if (unsigned Jmp_buf = SpecialTypes[pch::SPECIAL_TYPE_jmp_buf]) {
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) {
Error("Invalid jmp_bug type in PCH file");
return;
}
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
Context->setjmp_bufDecl(Tag->getDecl());
}
}
if (unsigned Sigjmp_buf = SpecialTypes[pch::SPECIAL_TYPE_sigjmp_buf]) {
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>();
Make longjmp a real builtin. llvm-svn: 77291
2009-07-28 10:25:19 +08:00
assert(Tag && "Invalid sigjmp_buf type in PCH file");
Context->setsigjmp_bufDecl(Tag->getDecl());
}
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (unsigned ObjCIdRedef
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
= SpecialTypes[pch::SPECIAL_TYPE_OBJC_ID_REDEFINITION])
Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (unsigned ObjCClassRedef
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
= SpecialTypes[pch::SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
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
if (unsigned String = SpecialTypes[pch::SPECIAL_TYPE_BLOCK_DESCRIPTOR])
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
= SpecialTypes[pch::SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
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
= SpecialTypes[pch::SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
if (unsigned String = SpecialTypes[pch::SPECIAL_TYPE_NS_CONSTANT_STRING])
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
if (SpecialTypes[pch::SPECIAL_TYPE_INT128_INSTALLED])
Context->setInt128Installed();
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
/// directly from the PCH file, without actually loading the PCH
/// file.
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
std::string PCHReader::getOriginalSourceFile(const std::string &PCHFileName,
Diagnostic &Diags) {
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
// Open the PCH file.
std::string ErrStr;
llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
Buffer.reset(llvm::MemoryBuffer::getFile(PCHFileName.c_str(), &ErrStr));
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') {
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
Diags.Report(diag::err_fe_not_a_pch_file) << PCHFileName;
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
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
// We only know the PCH subblock ID.
switch (BlockID) {
case pch::PCH_BLOCK_ID:
if (Stream.EnterSubBlock(pch::PCH_BLOCK_ID)) {
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
Diags.Report(diag::err_fe_pch_malformed_block) << PCHFileName;
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()) {
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
Diags.Report(diag::err_fe_pch_malformed_block) << PCHFileName;
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()) {
Switch PCHReader::getOriginalSourceFile to use proper diagnostics. llvm-svn: 90434
2009-12-03 17:13:06 +08:00
Diags.Report(diag::err_fe_pch_error_at_end_block) << PCHFileName;
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)
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
== pch::ORIGINAL_FILE_NAME)
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.
///
/// This routine compares the language options used to generate the
/// PCH file against the language options set for the current
/// compilation. For each option, we classify differences between the
/// two compiler states as either "benign" or "important". Benign
/// differences don't matter, and we accept them without complaint
/// (and without modifying the language options). Differences between
/// the states for important options cause the PCH file to be
/// unusable, so we emit a warning and return true to indicate that
/// there was an error.
///
/// \returns true if the PCH file is unacceptable, false otherwise.
bool PCHReader::ParseLanguageOptions(
const llvm::SmallVectorImpl<uint64_t> &Record) {
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);
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);
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);
clang -cc1: Add -fsjlj-exceptions, which requires far too much button pushing. llvm-svn: 95785
2010-02-11 02:48:44 +08:00
PARSE_LANGOPT(SjLjExceptions);
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);
PARSE_LANGOPT(AccessControl);
PARSE_LANGOPT(CharIsSigned);
Adding -fshort-wchar option. llvm-svn: 86167
2009-11-06 04:14:16 +08:00
PARSE_LANGOPT(ShortWChar);
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++]);
LangOpts.setVisibilityMode((LangOptions::VisibilityMode)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);
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);
// FIXME: Missing ElideConstructors?!
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;
}
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
void PCHReader::ReadPreprocessedEntities() {
ReadDefinedMacros();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
/// \brief Read and return the type at the given offset.
///
/// This routine actually reads the record corresponding to the type
/// at the given offset in the bitstream. It is a helper routine for
/// GetType, which deals with reading type IDs.
QualType PCHReader::ReadTypeRecord(uint64_t Offset) {
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);
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.
LoadingTypeOrDecl Loading(*this);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Merge the "types" and "declarations" blocks in the precompiled header format, so that we don't end up with multiple declaration and types blocks. Also, fix a few obscure bugs with PCH loading and generation: - If the DeclIDs DenseMap reallocates while we are writing a declaration (due to recursively writing other declarations), we could end up writing a bad ID to ExternalDefinitions. - When loading an ArrayLoc (part of DeclaratorInfo), we need to set the size expression to NULL if no size expression was provided. PCH -> AST rewriting is still partly broken, unfortunately. llvm-svn: 84293
2009-10-17 08:13:19 +08:00
DeclsCursor.JumpToBit(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();
switch ((pch::TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
PCH support for ExtQualType llvm-svn: 69230
2009-04-16 06:00:08 +08:00
case pch::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();
}
PCH support for ExtQualType llvm-svn: 69230
2009-04-16 06:00:08 +08:00
QualType Base = GetType(Record[0]);
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
Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]);
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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 pch::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();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 ElemType = GetType(Record[0]);
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
}
case pch::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();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 PointeeType = GetType(Record[0]);
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
}
case pch::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();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 PointeeType = GetType(Record[0]);
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
}
case pch::TYPE_LVALUE_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 lvalue reference type");
return QualType();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 PointeeType = GetType(Record[0]);
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->getLValueReferenceType(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
}
case pch::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();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 PointeeType = GetType(Record[0]);
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
}
case pch::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();
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 PointeeType = GetType(Record[0]);
QualType ClassType = GetType(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->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
}
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
case pch::TYPE_CONSTANT_ARRAY: {
QualType ElementType = GetType(Record[0]);
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
unsigned Idx = 3;
llvm::APInt Size = ReadAPInt(Record, Idx);
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);
}
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
case pch::TYPE_INCOMPLETE_ARRAY: {
QualType ElementType = GetType(Record[0]);
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
}
case pch::TYPE_VARIABLE_ARRAY: {
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
QualType ElementType = GetType(Record[0]);
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
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
SourceLocation LBLoc = SourceLocation::getFromRawEncoding(Record[3]);
SourceLocation RBLoc = SourceLocation::getFromRawEncoding(Record[4]);
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
return Context->getVariableArrayType(ElementType, ReadExpr(),
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
}
case pch::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) {
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 vector type in PCH 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();
}
QualType ElementType = GetType(Record[0]);
unsigned NumElements = Record[1];
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
unsigned AltiVecSpec = Record[2];
return Context->getVectorType(ElementType, NumElements,
(VectorType::AltiVecSpecific)AltiVecSpec);
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
}
case pch::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) {
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 extended vector type in PCH 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();
}
QualType ElementType = GetType(Record[0]);
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
}
case pch::TYPE_FUNCTION_NO_PROTO: {
Remember the regparm attribute in FunctionType::ExtInfo. Fixes PR3782. llvm-svn: 99940
2010-03-31 06:15:11 +08:00
if (Record.size() != 4) {
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();
}
QualType ResultType = GetType(Record[0]);
Remember the regparm attribute in FunctionType::ExtInfo. Fixes PR3782. llvm-svn: 99940
2010-03-31 06:15:11 +08:00
FunctionType::ExtInfo Info(Record[1], Record[2], (CallingConv)Record[3]);
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
}
case pch::TYPE_FUNCTION_PROTO: {
QualType ResultType = GetType(Record[0]);
Serialize the NoReturn bit on FunctionTypes for precompiled headers llvm-svn: 91911
2009-12-23 02:11:50 +08:00
bool NoReturn = Record[1];
Remember the regparm attribute in FunctionType::ExtInfo. Fixes PR3782. llvm-svn: 99940
2010-03-31 06:15:11 +08:00
unsigned RegParm = Record[2];
CallingConv CallConv = (CallingConv)Record[3];
unsigned Idx = 4;
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++];
llvm::SmallVector<QualType, 16> ParamTypes;
for (unsigned I = 0; I != NumParams; ++I)
ParamTypes.push_back(GetType(Record[Idx++]));
bool isVariadic = Record[Idx++];
unsigned Quals = Record[Idx++];
Reintroduce the home for exception specs, and make Sema fill it. However, keep the spec out of the canonical type this time. Net effect is currently nothing, because the spec isn't checked anywhere. llvm-svn: 72498
2009-05-28 06:11:52 +08:00
bool hasExceptionSpec = Record[Idx++];
bool hasAnyExceptionSpec = Record[Idx++];
unsigned NumExceptions = Record[Idx++];
llvm::SmallVector<QualType, 2> Exceptions;
for (unsigned I = 0; I != NumExceptions; ++I)
Exceptions.push_back(GetType(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
return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
Reintroduce the home for exception specs, and make Sema fill it. However, keep the spec out of the canonical type this time. Net effect is currently nothing, because the spec isn't checked anywhere. llvm-svn: 72498
2009-05-28 06:11:52 +08:00
isVariadic, Quals, hasExceptionSpec,
hasAnyExceptionSpec, NumExceptions,
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
Exceptions.data(),
Remember the regparm attribute in FunctionType::ExtInfo. Fixes PR3782. llvm-svn: 99940
2010-03-31 06:15:11 +08:00
FunctionType::ExtInfo(NoReturn, RegParm,
CallConv));
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
}
Fix "using typename" and the instantiation of non-dependent using declarations. llvm-svn: 90614
2009-12-05 06:46:56 +08:00
case pch::TYPE_UNRESOLVED_USING:
return Context->getTypeDeclType(
cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0])));
- 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
case pch::TYPE_TYPEDEF: {
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();
}
- 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
TypedefDecl *Decl = cast<TypedefDecl>(GetDecl(Record[0]));
QualType Canonical = GetType(Record[1]);
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
case pch::TYPE_TYPEOF_EXPR:
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
return Context->getTypeOfExprType(ReadExpr());
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
case pch::TYPE_TYPEOF: {
if (Record.size() != 1) {
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 typeof(type) in PCH 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();
}
QualType UnderlyingType = GetType(Record[0]);
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
Add a DecltypeType type. llvm-svn: 74099
2009-06-25 03:06:50 +08:00
case pch::TYPE_DECLTYPE:
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
return Context->getDecltypeType(ReadExpr());
Add a DecltypeType type. llvm-svn: 74099
2009-06-25 03:06:50 +08:00
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
case pch::TYPE_RECORD: {
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();
}
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[0];
QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1])));
T->Dependent = IsDependent;
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
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
case pch::TYPE_ENUM: {
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();
}
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[0];
QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1])));
T->Dependent = IsDependent;
return T;
}
Add PCH support for enumerations and enumerators. llvm-svn: 68974
2009-04-14 02:14:40 +08:00
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
case pch::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++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
QualType NamedType = GetType(Record[Idx++]);
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
}
Remove ObjCQualifiedInterfaceType:-) llvm-svn: 76321
2009-07-18 23:33:26 +08:00
case pch::TYPE_OBJC_INTERFACE: {
deserialization support for qualified interfaces llvm-svn: 69782
2009-04-22 14:45:28 +08:00
unsigned Idx = 0;
ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(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);
}
case pch::TYPE_OBJC_OBJECT: {
unsigned Idx = 0;
QualType Base = GetType(Record[Idx++]);
deserialization support for qualified interfaces llvm-svn: 69782
2009-04-22 14:45:28 +08:00
unsigned NumProtos = Record[Idx++];
llvm::SmallVector<ObjCProtocolDecl*, 4> Protos;
for (unsigned I = 0; I != NumProtos; ++I)
Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(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->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
First step toward fixing <rdar://problem/6613046> refactor clang objc type representation. Add a type (ObjCObjectPointerType) and remove a type (ObjCQualifiedIdType). This large/tedious patch is just a first step. Next step is to remove ObjCQualifiedInterfaceType. After that, I will remove the magic TypedefType for 'id' (installed by Sema). This work will enable various simplifications throughout clang (when dealing with ObjC types). No functionality change. llvm-svn: 73649
2009-06-18 06:40:22 +08:00
case pch::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;
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
QualType Pointee = GetType(Record[Idx++]);
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
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
case pch::TYPE_SUBST_TEMPLATE_TYPE_PARM: {
unsigned Idx = 0;
QualType Parm = GetType(Record[Idx++]);
QualType Replacement = GetType(Record[Idx++]);
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
case pch::TYPE_INJECTED_CLASS_NAME: {
CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0]));
QualType TST = GetType(Record[1]); // 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
// for PCH reading, too much interdependencies.
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
}
Initial support for writing templates to PCH. llvm-svn: 106391
2010-06-20 03:28:53 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case pch::TYPE_TEMPLATE_TYPE_PARM: {
unsigned Idx = 0;
unsigned Depth = Record[Idx++];
unsigned Index = Record[Idx++];
bool Pack = Record[Idx++];
IdentifierInfo *Name = GetIdentifierInfo(Record, Idx);
return Context->getTemplateTypeParmType(Depth, Index, Pack, Name);
}
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
case pch::TYPE_DEPENDENT_NAME: {
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
Fix reading of DependentNameType. llvm-svn: 107474
2010-07-02 19:55:24 +08:00
QualType Canon = GetType(Record[Idx++]);
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
}
Support DependentTemplateSpecializationType and ElaboratedType for PCH. llvm-svn: 106858
2010-06-26 00:24:58 +08:00
case pch::TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
unsigned NumArgs = Record[Idx++];
llvm::SmallVector<TemplateArgument, 8> Args;
Args.reserve(NumArgs);
while (NumArgs--)
Args.push_back(ReadTemplateArgument(Record, Idx));
return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
Args.size(), Args.data());
}
Support DependentSizedArrayType for PCH. llvm-svn: 107267
2010-06-30 16:49:25 +08:00
case pch::TYPE_DEPENDENT_SIZED_ARRAY: {
unsigned Idx = 0;
// ArrayType
QualType ElementType = GetType(Record[Idx++]);
ArrayType::ArraySizeModifier ASM
= (ArrayType::ArraySizeModifier)Record[Idx++];
unsigned IndexTypeQuals = Record[Idx++];
// DependentSizedArrayType
Expr *NumElts = ReadExpr();
SourceRange Brackets = ReadSourceRange(Record, Idx);
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
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case pch::TYPE_TEMPLATE_SPECIALIZATION: {
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++];
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
TemplateName Name = ReadTemplateName(Record, Idx);
llvm::SmallVector<TemplateArgument, 8> Args;
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
ReadTemplateArgumentList(Args, Record, Idx);
QualType Canon = GetType(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;
- 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 (Canon.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(),
Args.size(), Canon);
T->Dependent = IsDependent;
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();
}
Factor out routines to encode/decode DeclaratorInfos and move them into the core PCH reader/writer implementation files. llvm-svn: 84278
2009-10-17 05:56:05 +08:00
namespace {
class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
PCHReader &Reader;
const PCHReader::RecordData &Record;
unsigned &Idx;
public:
TypeLocReader(PCHReader &Reader, const PCHReader::RecordData &Record,
unsigned &Idx)
: Reader(Reader), Record(Record), Idx(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
// 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) {
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
TL.setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
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) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(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) {
TL.setStarLoc(SourceLocation::getFromRawEncoding(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) {
TL.setCaretLoc(SourceLocation::getFromRawEncoding(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) {
TL.setAmpLoc(SourceLocation::getFromRawEncoding(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) {
TL.setAmpAmpLoc(SourceLocation::getFromRawEncoding(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) {
TL.setStarLoc(SourceLocation::getFromRawEncoding(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) {
TL.setLBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRBracketLoc(SourceLocation::getFromRawEncoding(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++])
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
TL.setSizeExpr(Reader.ReadExpr());
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) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
FunctionTypeLocs don't necessarily provide ParmVarDecls, so don't crash if one was PCH'ed without any. llvm-svn: 84920
2009-10-23 09:28:53 +08:00
TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(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) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(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::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Add type source information for both kinds of typeof types. Patch by Enea Zaffanella. llvm-svn: 93344
2010-01-14 04:03:27 +08:00
TL.setTypeofLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRParenLoc(SourceLocation::getFromRawEncoding(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) {
Add type source information for both kinds of typeof types. Patch by Enea Zaffanella. llvm-svn: 93344
2010-01-14 04:03:27 +08:00
TL.setTypeofLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(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) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(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
void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
SubstTemplateTypeParmTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(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) {
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
TL.setTemplateNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
TL.setArgLocInfo(i,
Reader.GetTemplateArgumentLocInfo(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
}
Merged Elaborated and QualifiedName types. llvm-svn: 103517
2010-05-12 05:36:43 +08:00
void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Added basic source locations to Elaborated and DependentName types. llvm-svn: 104169
2010-05-20 05:37:53 +08:00
TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setQualifierRange(Reader.ReadSourceRange(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) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
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) {
Added basic source locations to Elaborated and DependentName types. llvm-svn: 104169
2010-05-20 05:37:53 +08:00
TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setQualifierRange(Reader.ReadSourceRange(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
TL.setNameLoc(SourceLocation::getFromRawEncoding(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
void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
DependentTemplateSpecializationTypeLoc TL) {
TL.setKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setQualifierRange(Reader.ReadSourceRange(Record, Idx));
TL.setNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
TL.setArgLocInfo(I,
Reader.GetTemplateArgumentLocInfo(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
void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
TL.setNameLoc(SourceLocation::getFromRawEncoding(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++]);
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
TL.setLAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
TL.setRAngleLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
TL.setProtocolLoc(i, SourceLocation::getFromRawEncoding(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) {
TL.setStarLoc(SourceLocation::getFromRawEncoding(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
}
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 *PCHReader::GetTypeSourceInfo(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) {
QualType InfoTy = GetType(Record[Idx++]);
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);
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
TypeLocReader TLR(*this, 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
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
QualType PCHReader::GetType(pch::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
if (Index < pch::NUM_PREDEF_TYPE_IDS) {
QualType T;
switch ((pch::PredefinedTypeIDs)Index) {
case pch::PREDEF_TYPE_NULL_ID: 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
case pch::PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
case pch::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
case pch::PREDEF_TYPE_CHAR_U_ID:
case pch::PREDEF_TYPE_CHAR_S_ID:
// 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;
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
case pch::PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break;
case pch::PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break;
case pch::PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break;
case pch::PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break;
case pch::PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break;
initial support for __[u]int128_t, which should be basically compatible with VC++ and GCC. The codegen/mangling angle hasn't been fully ironed out yet. Note that we accept int128_t even in 32-bit mode, unlike gcc. llvm-svn: 70464
2009-04-30 10:43:43 +08:00
case pch::PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break;
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
case pch::PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break;
case pch::PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break;
case pch::PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break;
case pch::PREDEF_TYPE_INT_ID: T = Context->IntTy; break;
case pch::PREDEF_TYPE_LONG_ID: T = Context->LongTy; break;
case pch::PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break;
initial support for __[u]int128_t, which should be basically compatible with VC++ and GCC. The codegen/mangling angle hasn't been fully ironed out yet. Note that we accept int128_t even in 32-bit mode, unlike gcc. llvm-svn: 70464
2009-04-30 10:43:43 +08:00
case pch::PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break;
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
case pch::PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break;
case pch::PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break;
case pch::PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break;
case pch::PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break;
case pch::PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break;
Implement C++0x nullptr. llvm-svn: 71405
2009-05-11 02:38:11 +08:00
case pch::PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break;
Basic support for C++0x unicode types. Support for literals will follow in an incremental patch llvm-svn: 75622
2009-07-14 14:30:34 +08:00
case pch::PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break;
case pch::PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break;
Implement the ObjC pseudo built-in types as clang "BuiltinType's". I say pseudo built-in types, since Sema still injects a typedef for recognition (i.e. they aren't truly built-ins from a parser perspective). This removes the static data/methods on ObjCObjectPointerType while preserving the nice API (no need to fiddle with ASTContext:-). This patch also adds Type::isObjCBuiltinType(). This should be the last fairly large patch related to recrafting the ObjC type system. The follow-on patches should be fairly small. llvm-svn: 75808
2009-07-16 02:40:39 +08:00
case pch::PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break;
case pch::PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break;
This patch implements objective-c's 'SEL' type as a built-in type and fixes a long-standing code gen. crash reported in at least two PRs and a radar. (radar 7405040 and pr5025). There are couple of remaining issues that I would like for Ted. and Doug to look at: Ted, please look at failure in Analysis/MissingDealloc.m. I have temporarily added an expected-warning to make the test pass. This tests has a declaration of 'SEL' type which may not co-exist with the new changes. Doug, please look at a FIXME in PCHWriter.cpp/PCHReader.cpp. I think the changes which I have ifdef'ed out are correct. They need be considered for in a few Indexer/PCH test cases. llvm-svn: 89561
2009-11-22 03:53:08 +08:00
case pch::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
}
Index -= pch::NUM_PREDEF_TYPE_IDS;
Remove ObjCQualifiedInterfaceType:-) llvm-svn: 76321
2009-07-18 23:33:26 +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()) {
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
TypesLoaded[Index] = ReadTypeRecord(TypeOffsets[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
TypesLoaded[Index]->setFromPCH();
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->TypeRead(ID >> Qualifiers::FastWidth,
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
}
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
PCHReader::GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
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:
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
return ReadExpr();
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:
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 GetTypeSourceInfo(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: {
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
SourceRange QualifierRange = ReadSourceRange(Record, Index);
SourceLocation TemplateNameLoc = ReadSourceLocation(Record, Index);
return TemplateArgumentLocInfo(QualifierRange, TemplateNameLoc);
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
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
PCHReader::ReadTemplateArgumentLoc(const RecordData &Record, unsigned &Index) {
TemplateArgument Arg = ReadTemplateArgument(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()));
}
-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
return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(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
}
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
Decl *PCHReader::GetExternalDecl(uint32_t ID) {
return GetDecl(ID);
}
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
TranslationUnitDecl *PCHReader::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]) {
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
ReadDeclRecord(DeclOffsets[0], 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
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]);
}
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
Decl *PCHReader::GetDecl(pch::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()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("declaration ID out-of-range for PCH 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]) {
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
ReadDeclRecord(DeclOffsets[Index], Index);
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 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).
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
Stmt *PCHReader::GetExternalDeclStmt(uint64_t Offset) {
read all decls (and attributes and stmts/exprs referenced by the decl) from the DeclsCursor. llvm-svn: 70190
2009-04-27 13:58:23 +08:00
// Since we know tha this statement is part of a decl, make sure to use the
// decl cursor to read it.
DeclsCursor.JumpToBit(Offset);
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
return ReadStmtFromStream(DeclsCursor);
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
}
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
bool PCHReader::FindExternalLexicalDecls(const DeclContext *DC,
llvm::SmallVectorImpl<Decl*> &Decls) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(DC->hasExternalLexicalStorage() &&
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 lexical decls in storage");
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
uint64_t Offset = DeclContextOffsets[DC].first;
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 (Offset == 0) {
Error("DeclContext has no lexical decls in storage");
return true;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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 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 context.
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Load the record containing all of the declarations lexically in
// this context.
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +08:00
DeclsCursor.JumpToBit(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;
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +08:00
unsigned Code = DeclsCursor.ReadCode();
unsigned RecCode = DeclsCursor.ReadRecord(Code, Record);
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 (RecCode != pch::DECL_CONTEXT_LEXICAL) {
Error("Expected lexical block");
return true;
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Load all of the declaration IDs
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
for (RecordData::iterator I = Record.begin(), E = Record.end(); I != E; ++I)
Decls.push_back(GetDecl(*I));
Add PCH statistics for the number/percent of lexical/visible declcontexts read llvm-svn: 69835
2009-04-23 06:34:57 +08:00
++NumLexicalDeclContextsRead;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
return false;
}
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
PCHReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
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");
uint64_t Offset = DeclContextOffsets[DC].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 (Offset == 0) {
Error("DeclContext has no visible decls in storage");
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 DeclContext::lookup_result(DeclContext::lookup_iterator(),
DeclContext::lookup_iterator());
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
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 context.
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +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
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
// Load the record containing all of the declarations visible in
// this context.
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +08:00
DeclsCursor.JumpToBit(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;
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +08:00
unsigned Code = DeclsCursor.ReadCode();
unsigned RecCode = DeclsCursor.ReadRecord(Code, Record);
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 (RecCode != pch::DECL_CONTEXT_VISIBLE) {
Error("Expected visible block");
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 DeclContext::lookup_result(DeclContext::lookup_iterator(),
DeclContext::lookup_iterator());
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
}
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
llvm::SmallVector<VisibleDeclaration, 64> Decls;
if (Record.empty()) {
SetExternalVisibleDecls(DC, Decls);
return DeclContext::lookup_result(DeclContext::lookup_iterator(),
DeclContext::lookup_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
unsigned Idx = 0;
while (Idx < Record.size()) {
Decls.push_back(VisibleDeclaration());
Decls.back().Name = ReadDeclarationName(Record, Idx);
unsigned Size = Record[Idx++];
fix a couple more places that should be using the DeclCursor instead of the normal stream cursor. llvm-svn: 70198
2009-04-27 15:35:40 +08:00
llvm::SmallVector<unsigned, 4> &LoadedDecls = Decls.back().Declarations;
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
LoadedDecls.reserve(Size);
for (unsigned I = 0; I < Size; ++I)
LoadedDecls.push_back(Record[Idx++]);
}
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
SetExternalVisibleDecls(DC, Decls);
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
}
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
void PCHReader::PassInterestingDeclsToConsumer() {
assert(Consumer);
while (!InterestingDecls.empty()) {
DeclGroupRef DG(InterestingDecls.front());
InterestingDecls.pop_front();
Consumer->HandleTopLevelDecl(DG);
}
}
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
void PCHReader::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
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
void PCHReader::PrintStats() {
std::fprintf(stderr, "*** PCH Statistics:\n");
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);
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 (TotalNumSLocEntries)
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));
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 (TotalNumSelectors)
std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
NumSelectorsLoaded, TotalNumSelectors,
((float)NumSelectorsLoaded/TotalNumSelectors * 100));
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));
if (TotalSelectorsInMethodPool) {
std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
NumMethodPoolSelectorsRead, TotalSelectorsInMethodPool,
((float)NumMethodPoolSelectorsRead/TotalSelectorsInMethodPool
* 100));
std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses);
}
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More 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");
}
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
void PCHReader::InitializeSema(Sema &S) {
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.
for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
SemaObj->TUScope->AddDecl(Action::DeclPtrTy::make(PreloadedDecls[I]));
SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
}
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
// If there were any tentative definitions, deserialize them and add
Add VarDecl::isThisDeclarationADefinition(), which properly encapsulates the logic for when a variable declaration is a (possibly tentativ) definition. Add a few functions building on this, and shift C tentative definition handling over to this new functionality. This shift also kills the Sema::TentativeDefinitions map and instead simply stores all declarations in the renamed list. The correct handling for multiple tentative definitions is instead shifted to the final walk of the list. llvm-svn: 94968
2010-02-01 06:27:38 +08:00
// them to Sema's list of tentative definitions.
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
for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I]));
Add VarDecl::isThisDeclarationADefinition(), which properly encapsulates the logic for when a variable declaration is a (possibly tentativ) definition. Add a few functions building on this, and shift C tentative definition handling over to this new functionality. This shift also kills the Sema::TentativeDefinitions map and instead simply stores all declarations in the renamed list. The correct handling for multiple tentative definitions is instead shifted to the final walk of the list. llvm-svn: 94968
2010-02-01 06:27:38 +08:00
SemaObj->TentativeDefinitions.push_back(Var);
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
}
Undefine correct macro llvm-svn: 97920
2010-03-08 03:10:13 +08:00
Implementing unused function warning. llvm-svn: 95940
2010-02-12 08:07:30 +08:00
// If there were any unused static functions, deserialize them and add to
// Sema's list of unused static functions.
for (unsigned I = 0, N = UnusedStaticFuncs.size(); I != N; ++I) {
FunctionDecl *FD = cast<FunctionDecl>(GetDecl(UnusedStaticFuncs[I]));
SemaObj->UnusedStaticFuncs.push_back(FD);
}
Support locally-declared external declarations in PCH files llvm-svn: 69833
2009-04-23 06:18:58 +08:00
// If there were any locally-scoped external declarations,
// deserialize them and add them to Sema's table of locally-scoped
// external declarations.
for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D;
}
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
// If there were any ext_vector type declarations, deserialize them
// and add them to Sema's vector of such declarations.
for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I)
SemaObj->ExtVectorDecls.push_back(
cast<TypedefDecl>(GetDecl(ExtVectorDecls[I])));
Add to PCH missing Sema information about VTable uses and dynamic classes. llvm-svn: 107664
2010-07-06 23:37:04 +08:00
// FIXME: Do VTable uses and dynamic classes deserialize too much ?
// Can we cut them down before writing them ?
// If there were any VTable uses, deserialize the information and add it
// to Sema's vector and map of VTable uses.
unsigned Idx = 0;
for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) {
CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
SourceLocation Loc = ReadSourceLocation(VTableUses, Idx);
bool DefinitionRequired = VTableUses[Idx++];
SemaObj->VTableUses.push_back(std::make_pair(Class, Loc));
SemaObj->VTablesUsed[Class] = DefinitionRequired;
}
// If there were any dynamic classes declarations, deserialize them
// and add them to Sema's vector of such declarations.
for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I)
SemaObj->DynamicClasses.push_back(
cast<CXXRecordDecl>(GetDecl(DynamicClasses[I])));
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* PCHReader::get(const char *NameStart, const char *NameEnd) {
// Try to find this name within our on-disk hash table
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCHIdentifierLookupTable *IdTable
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
= (PCHIdentifierLookupTable *)IdentifierLookupTable;
std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
PCHIdentifierLookupTable::iterator Pos = IdTable->find(Key);
if (Pos == IdTable->end())
return 0;
// Dereferencing the iterator has the effect of building the
// IdentifierInfo node and populating it with the various
// declarations it needs.
return *Pos;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
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
PCHReader::ReadMethodPool(Selector Sel) {
if (!MethodPoolLookupTable)
return std::pair<ObjCMethodList, ObjCMethodList>();
// Try to find this selector within our on-disk hash table.
PCHMethodPoolLookupTable *PoolTable
= (PCHMethodPoolLookupTable*)MethodPoolLookupTable;
PCHMethodPoolLookupTable::iterator Pos = PoolTable->find(Sel);
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 (Pos == PoolTable->end()) {
++NumMethodPoolMisses;
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
return std::pair<ObjCMethodList, ObjCMethodList>();;
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
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
++NumMethodPoolSelectorsRead;
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
return *Pos;
}
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
void PCHReader::SetIdentifierInfo(unsigned 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;
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.
///
/// If the PCH 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
PCHReader::SetGloballyVisibleDecls(IdentifierInfo *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
const llvm::SmallVectorImpl<uint32_t> &DeclIDs,
bool Nonrecursive) {
if (CurrentlyLoadingTypeOrDecl && !Nonrecursive) {
PendingIdentifierInfos.push_back(PendingIdentifierInfo());
PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
PII.II = II;
for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I)
PII.DeclIDs.push_back(DeclIDs[I]);
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) {
// 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.
SemaObj->TUScope->AddDecl(Action::DeclPtrTy::make(D));
SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
} 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);
}
}
}
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
IdentifierInfo *PCHReader::DecodeIdentifierInfo(unsigned 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
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 (!IdentifierTableData || IdentifiersLoaded.empty()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("no identifier table in PCH 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 ?");
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[ID - 1]) {
uint32_t Offset = IdentifierOffsets[ID - 1];
Optimize the loading of an identifier from a PCH file when given the identifier's ID. In this case, we know where the identifier's entry is located in the hash table (it starts right before the identifier string itself), so skip the hash table lookup and read the entry directly. The performance improvement here is, gain, hard to quantify, but it's the right thing to do. llvm-svn: 70078
2009-04-26 05:21:38 +08:00
const char *Str = IdentifierTableData + Offset;
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
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
// All of the strings in the PCH 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;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
IdentifiersLoaded[ID - 1]
Add IdentifierTable::get() overload and start using it llvm-svn: 98343
2010-03-12 18:32:27 +08:00
= &PP->getIdentifierTable().get(Str, StrLen);
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
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
return IdentifiersLoaded[ID - 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
}
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
void PCHReader::ReadSLocEntry(unsigned ID) {
ReadSLocEntryRecord(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
Selector PCHReader::DecodeSelector(unsigned ID) {
if (ID == 0)
return Selector();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
if (!MethodPoolLookupTableData)
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
if (ID > TotalNumSelectors) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("selector ID out of range in PCH 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
unsigned Index = ID - 1;
if (SelectorsLoaded[Index].getAsOpaquePtr() == 0) {
// Load this selector from the selector table.
// FIXME: endianness portability issues with SelectorOffsets table
PCHMethodPoolLookupTrait Trait(*this);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SelectorsLoaded[Index]
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
= Trait.ReadKey(MethodPoolLookupTableData + SelectorOffsets[Index], 0);
}
return SelectorsLoaded[Index];
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
}
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
Selector PCHReader::GetExternalSelector(uint32_t 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);
}
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
uint32_t PCHReader::GetNumExternalSelectors() {
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 TotalNumSelectors + 1;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
DeclarationName
Implementation of pre-compiled headers (PCH) based on lazy de-serialization of abstract syntax trees. PCH support serializes the contents of the abstract syntax tree (AST) to a bitstream. When the PCH file is read, declarations are serialized as-needed. For example, a declaration of a variable "x" will be deserialized only when its VarDecl can be found by a client, e.g., based on name lookup for "x" or traversing the entire contents of the owner of "x". This commit provides the framework for serialization and (lazy) deserialization, along with support for variable and typedef declarations (along with several kinds of types). More declarations/types, along with important auxiliary structures (source manager, preprocessor, etc.), will follow. llvm-svn: 68732
2009-04-10 06:27:44 +08:00
PCHReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) {
DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
switch (Kind) {
case DeclarationName::Identifier:
return DeclarationName(GetIdentifierInfo(Record, Idx));
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Sema::ActOnStartClassInterface(): Use PushOnScopeChains(). This enables class recognition to work with PCH. I believe this means we can remove Sema::ObjCInterfaceDecls and it's usage within Sema::LookupName(). Will investigate. llvm-svn: 69891
2009-04-23 23:15:40 +08:00
return DeclarationName(GetSelector(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(
Introduce the canonical type smart pointers, and use them in a few places to tighten up the static type system. llvm-svn: 78164
2009-08-05 13:36:45 +08:00
Context->getCanonicalType(GetType(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(
Introduce the canonical type smart pointers, and use them in a few places to tighten up the static type system. llvm-svn: 78164
2009-08-05 13:36:45 +08:00
Context->getCanonicalType(GetType(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(
Introduce the canonical type smart pointers, and use them in a few places to tighten up the static type system. llvm-svn: 78164
2009-08-05 13:36:45 +08:00
Context->getCanonicalType(GetType(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(
GetIdentifierInfo(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::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
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
TemplateName
PCHReader::ReadTemplateName(const RecordData &Record, unsigned &Idx) {
TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
switch (Kind) {
case TemplateName::Template:
return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++])));
case TemplateName::OverloadedTemplate: {
unsigned size = Record[Idx++];
UnresolvedSet<8> Decls;
while (size--)
Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++])));
return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
}
case TemplateName::QualifiedTemplate: {
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
bool hasTemplKeyword = Record[Idx++];
TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++]));
return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
}
case TemplateName::DependentTemplate: {
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
if (Record[Idx++]) // isIdentifier
return Context->getDependentTemplateName(NNS,
GetIdentifierInfo(Record, Idx));
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
}
}
assert(0 && "Unhandled template name kind!");
return TemplateName();
}
TemplateArgument
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
PCHReader::ReadTemplateArgument(const RecordData &Record, unsigned &Idx) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
switch ((TemplateArgument::ArgKind)Record[Idx++]) {
case TemplateArgument::Null:
return TemplateArgument();
case TemplateArgument::Type:
return TemplateArgument(GetType(Record[Idx++]));
case TemplateArgument::Declaration:
return TemplateArgument(GetDecl(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);
QualType T = GetType(Record[Idx++]);
return TemplateArgument(Value, T);
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case TemplateArgument::Template:
return TemplateArgument(ReadTemplateName(Record, Idx));
case TemplateArgument::Expression:
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
return TemplateArgument(ReadExpr());
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++];
llvm::SmallVector<TemplateArgument, 8> Args;
Args.reserve(NumArgs);
while (NumArgs--)
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
Args.push_back(ReadTemplateArgument(Record, Idx));
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
TemplateArgument TemplArg;
TemplArg.setArgumentPack(Args.data(), Args.size(), /*CopyArgs=*/true);
return TemplArg;
}
}
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 *
PCHReader::ReadTemplateParameterList(const RecordData &Record, unsigned &Idx) {
SourceLocation TemplateLoc = ReadSourceLocation(Record, Idx);
SourceLocation LAngleLoc = ReadSourceLocation(Record, Idx);
SourceLocation RAngleLoc = ReadSourceLocation(Record, Idx);
unsigned NumParams = Record[Idx++];
llvm::SmallVector<NamedDecl *, 16> Params;
Params.reserve(NumParams);
while (NumParams--)
Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++])));
TemplateParameterList* TemplateParams =
TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
Params.data(), Params.size(), RAngleLoc);
return TemplateParams;
}
void
PCHReader::
ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs,
const RecordData &Record, unsigned &Idx) {
unsigned NumTemplateArgs = Record[Idx++];
TemplArgs.reserve(NumTemplateArgs);
while (NumTemplateArgs--)
TemplArgs.push_back(ReadTemplateArgument(Record, Idx));
}
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
/// \brief Read a UnresolvedSet structure.
void PCHReader::ReadUnresolvedSet(UnresolvedSetImpl &Set,
const RecordData &Record, unsigned &Idx) {
unsigned NumDecls = Record[Idx++];
while (NumDecls--) {
NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++]));
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
PCHReader::ReadCXXBaseSpecifier(const RecordData &Record, unsigned &Idx) {
bool isVirtual = static_cast<bool>(Record[Idx++]);
bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
QualType T = GetType(Record[Idx++]);
SourceRange Range = ReadSourceRange(Record, Idx);
return CXXBaseSpecifier(Range, isVirtual, isBaseOfClass, AS, T);
}
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 *
PCHReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) {
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: {
IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
NNS = NestedNameSpecifier::Create(*Context, Prev, II);
break;
}
case NestedNameSpecifier::Namespace: {
NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
break;
}
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
Type *T = GetType(Record[Idx++]).getTypePtr();
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;
}
SourceRange
PCHReader::ReadSourceRange(const RecordData &Record, unsigned &Idx) {
Fix undefined behavior, noticed by GCC 4.5. Patch by Dimitry Andric! llvm-svn: 105329
2010-06-02 23:47:10 +08:00
SourceLocation beg = SourceLocation::getFromRawEncoding(Record[Idx++]);
SourceLocation end = SourceLocation::getFromRawEncoding(Record[Idx++]);
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
llvm::APInt PCHReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
unsigned BitWidth = Record[Idx++];
unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
Idx += NumWords;
return Result;
}
/// \brief Read a signed integral value
llvm::APSInt PCHReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
bool isUnsigned = Record[Idx++];
return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
}
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
llvm::APFloat PCHReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
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
std::string PCHReader::ReadString(const RecordData &Record, unsigned &Idx) {
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;
}
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
CXXTemporary *PCHReader::ReadCXXTemporary(const RecordData &Record,
unsigned &Idx) {
CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++]));
return CXXTemporary::Create(*Context, Decl);
}
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
DiagnosticBuilder PCHReader::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);
}
DiagnosticBuilder PCHReader::Diag(SourceLocation Loc, unsigned DiagID) {
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 Diags.Report(FullSourceLoc(Loc, SourceMgr), 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.
IdentifierTable &PCHReader::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.
void PCHReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
SwitchCaseStmts[ID] = SC;
}
/// \brief Retrieve the switch-case statement with the given ID.
SwitchCase *PCHReader::getSwitchCaseWithID(unsigned ID) {
assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
return SwitchCaseStmts[ID];
}
PCH support for labels and goto. llvm-svn: 69364
2009-04-18 02:18:49 +08:00
/// \brief Record that the given label statement has been
/// deserialized and has the given ID.
void PCHReader::RecordLabelStmt(LabelStmt *S, unsigned ID) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(LabelStmts.find(ID) == LabelStmts.end() &&
PCH support for labels and goto. llvm-svn: 69364
2009-04-18 02:18:49 +08:00
"Deserialized label twice");
LabelStmts[ID] = S;
// If we've already seen any goto statements that point to this
// label, resolve them now.
typedef std::multimap<unsigned, GotoStmt *>::iterator GotoIter;
std::pair<GotoIter, GotoIter> Gotos = UnresolvedGotoStmts.equal_range(ID);
for (GotoIter Goto = Gotos.first; Goto != Gotos.second; ++Goto)
Goto->second->setLabel(S);
UnresolvedGotoStmts.erase(Gotos.first, Gotos.second);
PCH support for indirect gotos and address-of-label expressions. llvm-svn: 69369
2009-04-18 02:58:21 +08:00
// If we've already seen any address-label statements that point to
// this label, resolve them now.
typedef std::multimap<unsigned, AddrLabelExpr *>::iterator AddrLabelIter;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<AddrLabelIter, AddrLabelIter> AddrLabels
PCH support for indirect gotos and address-of-label expressions. llvm-svn: 69369
2009-04-18 02:58:21 +08:00
= UnresolvedAddrLabelExprs.equal_range(ID);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
for (AddrLabelIter AddrLabel = AddrLabels.first;
PCH support for indirect gotos and address-of-label expressions. llvm-svn: 69369
2009-04-18 02:58:21 +08:00
AddrLabel != AddrLabels.second; ++AddrLabel)
AddrLabel->second->setLabel(S);
UnresolvedAddrLabelExprs.erase(AddrLabels.first, AddrLabels.second);
PCH support for labels and goto. llvm-svn: 69364
2009-04-18 02:18:49 +08:00
}
/// \brief Set the label of the given statement to the label
/// identified by ID.
///
/// Depending on the order in which the label and other statements
/// referencing that label occur, this operation may complete
/// immediately (updating the statement) or it may queue the
/// statement to be back-patched later.
void PCHReader::SetLabelOf(GotoStmt *S, unsigned ID) {
std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID);
if (Label != LabelStmts.end()) {
// We've already seen this label, so set the label of the goto and
// we're done.
S->setLabel(Label->second);
} else {
// We haven't seen this label yet, so add this goto to the set of
// unresolved goto statements.
UnresolvedGotoStmts.insert(std::make_pair(ID, S));
}
}
PCH support for indirect gotos and address-of-label expressions. llvm-svn: 69369
2009-04-18 02:58:21 +08:00
/// \brief Set the label of the given expression to the label
/// identified by ID.
///
/// Depending on the order in which the label and other statements
/// referencing that label occur, this operation may complete
/// immediately (updating the statement) or it may queue the
/// statement to be back-patched later.
void PCHReader::SetLabelOf(AddrLabelExpr *S, unsigned ID) {
std::map<unsigned, LabelStmt *>::iterator Label = LabelStmts.find(ID);
if (Label != LabelStmts.end()) {
// We've already seen this label, so set the label of the
// label-address expression and we're done.
S->setLabel(Label->second);
} else {
// We haven't seen this label yet, so add this label-address
// expression to the set of unresolved label-address expressions.
UnresolvedAddrLabelExprs.insert(std::make_pair(ID, S));
}
}
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
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PCHReader::LoadingTypeOrDecl::LoadingTypeOrDecl(PCHReader &Reader)
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(Reader), Parent(Reader.CurrentlyLoadingTypeOrDecl) {
Reader.CurrentlyLoadingTypeOrDecl = this;
}
PCHReader::LoadingTypeOrDecl::~LoadingTypeOrDecl() {
if (!Parent) {
// If any identifiers with corresponding top-level declarations have
// been loaded, load those declarations now.
while (!Reader.PendingIdentifierInfos.empty()) {
Reader.SetGloballyVisibleDecls(Reader.PendingIdentifierInfos.front().II,
Reader.PendingIdentifierInfos.front().DeclIDs,
true);
Reader.PendingIdentifierInfos.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.
if (Reader.Consumer)
Reader.PassInterestingDeclsToConsumer();
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
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Reader.CurrentlyLoadingTypeOrDecl = Parent;
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
}